FilesExpand file tree

 main

/

fix-default-stubs.mjs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

160 lines (139 loc) · 5.25 KB

 main

/

fix-default-stubs.mjs

Copy path

Top

File metadata and controls

• Code
• Blame

160 lines (139 loc) · 5.25 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

#!/usr/bin/env node

/**

* Finds all stub files with `export default {} as any` and rewrites them

* with proper named exports based on what the source code actually imports.

*/

import { execSync } from 'child_process';

import { readFileSync, writeFileSync, existsSync } from 'fs';

import { dirname, join, relative, resolve } from 'path';

const ROOT = '/Users/konghayao/code/ai/claude-code';

// Step 1: Find all stub files with only `export default {} as any`

const stubFiles = new Set();

const allTsFiles = execSync('find src -name "*.ts" -o -name "*.tsx"', {

encoding: 'utf-8', cwd: ROOT

}).trim().split('\n');

for (const f of allTsFiles) {

const fullPath = join(ROOT, f);

const content = readFileSync(fullPath, 'utf-8').trim();

if (content === 'export default {} as any') {

stubFiles.add(f); // relative path like src/types/message.ts

}

}

console.log(`Found ${stubFiles.size} stub files with 'export default {} as any'`);

// Step 2: Scan all source files for imports from these stub modules

// Map: stub file path -> { types: Set<string>, values: Set<string> }

const stubNeeds = new Map();

for (const sf of stubFiles) {

stubNeeds.set(sf, { types: new Set(), values: new Set() });

}

// Helper: resolve an import path from a source file to a stub file

function resolveImport(srcFile, importPath) {

// Handle src/ prefix imports

if (importPath.startsWith('src/')) {

const resolved = importPath.replace(/\.js$/, '.ts');

if (stubFiles.has(resolved)) return resolved;

return null;

}

// Handle relative imports

if (importPath.startsWith('.')) {

const srcDir = dirname(srcFile);

const resolved = join(srcDir, importPath).replace(/\.js$/, '.ts');

if (stubFiles.has(resolved)) return resolved;

// Try .tsx

const resolvedTsx = join(srcDir, importPath).replace(/\.js$/, '.tsx');

if (stubFiles.has(resolvedTsx)) return resolvedTsx;

return null;

}

return null;

}

for (const srcFile of allTsFiles) {

if (stubFiles.has(srcFile)) continue; // skip stub files themselves

const fullPath = join(ROOT, srcFile);

const content = readFileSync(fullPath, 'utf-8');

// Match: import type { A, B } from 'path'

const typeImportRegex = /import\s+type\s+\{([^}]+)\}\s+from\s+['"](.+?)['"]/g;

let match;

while ((match = typeImportRegex.exec(content)) !== null) {

const members = match[1].split(',').map(s => {

const parts = s.trim().split(/\s+as\s+/);

return parts[0].trim();

}).filter(Boolean);

const resolved = resolveImport(srcFile, match[2]);

if (resolved && stubNeeds.has(resolved)) {

for (const m of members) stubNeeds.get(resolved).types.add(m);

}

}

// Match: import { A, B } from 'path' (NOT import type)

const valueImportRegex = /import\s+(?!type\s)\{([^}]+)\}\s+from\s+['"](.+?)['"]/g;

while ((match = valueImportRegex.exec(content)) !== null) {

const rawMembers = match[1];

const members = rawMembers.split(',').map(s => {

// Handle `type Foo` inline type imports

const trimmed = s.trim();

if (trimmed.startsWith('type ')) {

return { name: trimmed.replace(/^type\s+/, '').split(/\s+as\s+/)[0].trim(), isType: true };

}

return { name: trimmed.split(/\s+as\s+/)[0].trim(), isType: false };

}).filter(m => m.name);

const resolved = resolveImport(srcFile, match[2]);

if (resolved && stubNeeds.has(resolved)) {

for (const m of members) {

if (m.isType) {

stubNeeds.get(resolved).types.add(m.name);

} else {

stubNeeds.get(resolved).values.add(m.name);

}

}

}

}

// Match: import Default from 'path'

const defaultImportRegex = /import\s+(?!type\s)(\w+)\s+from\s+['"](.+?)['"]/g;

while ((match = defaultImportRegex.exec(content)) !== null) {

const name = match[1];

if (name === 'type') continue;

const resolved = resolveImport(srcFile, match[2]);

if (resolved && stubNeeds.has(resolved)) {

stubNeeds.get(resolved).values.add('__default__:' + name);

}

}

}

// Step 3: Rewrite stub files

let updated = 0;

for (const [stubFile, needs] of stubNeeds) {

const fullPath = join(ROOT, stubFile);

const lines = ['// Auto-generated stub — replace with real implementation'];

let hasDefault = false;

// Add type exports

for (const t of needs.types) {

// Don't add as type if also in values

if (!needs.values.has(t)) {

lines.push(`export type ${t} = any;`);

}

}

// Add value exports (as const with any type)

for (const v of needs.values) {

if (v.startsWith('__default__:')) {

hasDefault = true;

continue;

}

// Check if it's likely a type (starts with uppercase and not a known function pattern)

// But since it's imported without `type`, treat as value to be safe

lines.push(`export const ${v}: any = (() => {}) as any;`);

}

// Add default export if needed

if (hasDefault) {

lines.push(`export default {} as any;`);

}

if (needs.types.size === 0 && needs.values.size === 0) {

lines.push('export {};');

}

writeFileSync(fullPath, lines.join('\n') + '\n');

updated++;

}

console.log(`Updated ${updated} stub files`);

// Print summary

for (const [stubFile, needs] of stubNeeds) {

if (needs.types.size > 0 || needs.values.size > 0) {

console.log(` ${stubFile}: ${needs.types.size} types, ${needs.values.size} values`);

}

}