octocode-cli 1.2.8 → 1.2.9

package/skills/octocode-engineer/src/analysis/dependencies.ts

@@ -0,0 +1,378 @@
+import path from 'node:path';
+
+import * as ts from 'typescript';
+
+import {
+  addToMapSet,
+  isRelativeImport,
+  isTestFile,
+  normalizeDependencyValue,
+  resolveImportTarget,
+  toRepoPath,
+} from '../common/utils.js';
+
+import type {
+  AnalysisOptions,
+  DependencyProfile,
+  DependencyRecord,
+  DependencyState,
+  ExportSymbol,
+  ImportedSymbolRef,
+  ReExportRef,
+} from '../types/index.js';
+
+function nodeLineRange(
+  sourceFile: ts.SourceFile,
+  node: ts.Node
+): { lineStart: number; lineEnd: number } {
+  return {
+    lineStart:
+      sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile))
+        .line + 1,
+    lineEnd:
+      sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line + 1,
+  };
+}
+
+function hasExportModifier(node: ts.Node): boolean {
+  if (!ts.canHaveModifiers(node)) return false;
+  return Boolean(
+    ts
+      .getModifiers(node)
+      ?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)
+  );
+}
+
+interface DependencyCollectorContext {
+  sourceFile: ts.SourceFile;
+  importedSymbols: ImportedSymbolRef[];
+  reExports: ReExportRef[];
+  pushDeclaredExport: (item: ExportSymbol) => void;
+  resolveSpecifier: (specifier: string | undefined) => string | null;
+}
+
+function collectImportSymbols(
+  node: ts.ImportDeclaration,
+  ctx: DependencyCollectorContext
+): void {
+  if (!node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier))
+    return;
+  const sourceModule = node.moduleSpecifier.text;
+  const resolvedModule = ctx.resolveSpecifier(sourceModule) ?? undefined;
+  const loc = nodeLineRange(ctx.sourceFile, node);
+  const clause = node.importClause;
+  if (!clause) return;
+  if (clause.name) {
+    ctx.importedSymbols.push({
+      sourceModule,
+      resolvedModule,
+      importedName: 'default',
+      localName: clause.name.text,
+      isTypeOnly: clause.isTypeOnly,
+      ...loc,
+    });
+  }
+  if (!clause.namedBindings) return;
+  if (ts.isNamespaceImport(clause.namedBindings)) {
+    ctx.importedSymbols.push({
+      sourceModule,
+      resolvedModule,
+      importedName: '*',
+      localName: clause.namedBindings.name.text,
+      isTypeOnly: clause.isTypeOnly,
+      ...loc,
+    });
+  } else {
+    for (const element of clause.namedBindings.elements) {
+      ctx.importedSymbols.push({
+        sourceModule,
+        resolvedModule,
+        importedName: element.propertyName?.text ?? element.name.text,
+        localName: element.name.text,
+        isTypeOnly: clause.isTypeOnly || element.isTypeOnly,
+        ...loc,
+      });
+    }
+  }
+}
+
+function collectReExportDeclaration(
+  node: ts.ExportDeclaration,
+  ctx: DependencyCollectorContext
+): void {
+  if (!node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier))
+    return;
+  const sourceModule = node.moduleSpecifier.text;
+  const resolvedModule = ctx.resolveSpecifier(sourceModule) ?? undefined;
+  if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+    for (const element of node.exportClause.elements) {
+      ctx.reExports.push({
+        sourceModule,
+        resolvedModule,
+        exportedAs: element.name.text,
+        importedName: element.propertyName?.text ?? element.name.text,
+        isStar: false,
+        isTypeOnly: node.isTypeOnly || element.isTypeOnly,
+        ...nodeLineRange(ctx.sourceFile, element),
+      });
+    }
+  } else {
+    ctx.reExports.push({
+      sourceModule,
+      resolvedModule,
+      exportedAs: '*',
+      importedName: '*',
+      isStar: true,
+      isTypeOnly: node.isTypeOnly,
+      ...nodeLineRange(ctx.sourceFile, node),
+    });
+  }
+}
+
+function collectDeclaredExportFromNode(
+  node: ts.Node,
+  ctx: DependencyCollectorContext
+): void {
+  const loc = nodeLineRange(ctx.sourceFile, node);
+
+  if (ts.isExportAssignment(node)) {
+    ctx.pushDeclaredExport({ name: 'default', kind: 'value', isDefault: true, ...loc });
+    return;
+  }
+
+  if (
+    (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) &&
+    hasExportModifier(node)
+  ) {
+    ctx.pushDeclaredExport({
+      name: node.name?.text || 'default',
+      kind: 'value',
+      isDefault: !node.name,
+      ...loc,
+    });
+    return;
+  }
+
+  if (ts.isEnumDeclaration(node) && hasExportModifier(node)) {
+    ctx.pushDeclaredExport({ name: node.name.text, kind: 'value', ...loc });
+    return;
+  }
+
+  if (
+    (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) &&
+    hasExportModifier(node)
+  ) {
+    ctx.pushDeclaredExport({ name: node.name.text, kind: 'type', ...loc });
+    return;
+  }
+
+  if (ts.isVariableStatement(node) && hasExportModifier(node)) {
+    for (const decl of node.declarationList.declarations) {
+      if (ts.isIdentifier(decl.name)) {
+        ctx.pushDeclaredExport({
+          name: decl.name.text,
+          kind: 'value',
+          ...nodeLineRange(ctx.sourceFile, decl),
+        });
+      }
+    }
+    return;
+  }
+
+  if (
+    ts.isExportDeclaration(node) &&
+    !node.moduleSpecifier &&
+    node.exportClause &&
+    ts.isNamedExports(node.exportClause)
+  ) {
+    for (const element of node.exportClause.elements) {
+      ctx.pushDeclaredExport({
+        name: element.name.text,
+        kind: element.isTypeOnly ? 'type' : 'unknown',
+        ...nodeLineRange(ctx.sourceFile, element),
+      });
+    }
+  }
+}
+
+function collectRequireCall(
+  node: ts.CallExpression,
+  ctx: DependencyCollectorContext
+): void {
+  if (
+    !ts.isIdentifier(node.expression) ||
+    node.expression.text !== 'require' ||
+    node.arguments.length !== 1 ||
+    !ts.isStringLiteral(node.arguments[0])
+  )
+    return;
+  const sourceModule = node.arguments[0].text;
+  const resolvedModule = ctx.resolveSpecifier(sourceModule) ?? undefined;
+  ctx.importedSymbols.push({
+    sourceModule,
+    resolvedModule,
+    importedName: '*',
+    localName: 'require',
+    isTypeOnly: false,
+    ...nodeLineRange(ctx.sourceFile, node),
+  });
+}
+
+export function collectModuleDependencies(
+  sourceFile: ts.SourceFile,
+  filePath: string,
+  repoRoot: string
+): DependencyProfile {
+  const currentDirectory = path.dirname(filePath);
+  const internal = new Set<string>();
+  const external = new Set<string>();
+  const unresolved = new Set<string>();
+  const declaredExports: ExportSymbol[] = [];
+
+  const pushDeclaredExport = (item: ExportSymbol): void => {
+    if (
+      declaredExports.some(
+        entry => entry.name === item.name && entry.kind === item.kind
+      )
+    )
+      return;
+    declaredExports.push(item);
+  };
+
+  const resolveSpecifier = (specifier: string | undefined): string | null => {
+    if (!specifier || typeof specifier !== 'string') return null;
+    if (!isRelativeImport(specifier)) {
+      external.add(specifier);
+      return null;
+    }
+    const resolved = resolveImportTarget(currentDirectory, specifier);
+    if (!resolved) {
+      unresolved.add(specifier);
+      return null;
+    }
+    if (!resolved.startsWith(repoRoot)) {
+      external.add(specifier);
+      return null;
+    }
+    const relativeResolved = normalizeDependencyValue(
+      path.relative(repoRoot, resolved)
+    );
+    internal.add(relativeResolved);
+    return relativeResolved;
+  };
+
+  const ctx: DependencyCollectorContext = {
+    sourceFile,
+    importedSymbols: [],
+    reExports: [],
+    pushDeclaredExport,
+    resolveSpecifier,
+  };
+
+  const visit = (node: ts.Node): void => {
+    if (ts.isImportDeclaration(node)) collectImportSymbols(node, ctx);
+    if (ts.isExportDeclaration(node) && node.moduleSpecifier) collectReExportDeclaration(node, ctx);
+    collectDeclaredExportFromNode(node, ctx);
+    if (ts.isCallExpression(node)) collectRequireCall(node, ctx);
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return {
+    internalDependencies: [...internal].sort(),
+    externalDependencies: [...external].sort(),
+    unresolvedDependencies: [...unresolved].sort(),
+    declaredExports,
+    importedSymbols: ctx.importedSymbols,
+    reExports: ctx.reExports,
+  };
+}
+
+export function trackDependencyEdge(
+  dependencyState: DependencyState,
+  fromFile: string,
+  toFile: string,
+  importerIsTest: boolean
+): void {
+  addToMapSet(dependencyState.outgoing, fromFile, toFile);
+  addToMapSet(dependencyState.incoming, toFile, fromFile);
+  if (importerIsTest) {
+    addToMapSet(dependencyState.incomingFromTests, toFile, fromFile);
+  } else {
+    addToMapSet(dependencyState.incomingFromProduction, toFile, fromFile);
+  }
+}
+
+export function collectDependencyProfile(
+  sourceFile: ts.SourceFile,
+  filePath: string,
+  packageName: string,
+  options: AnalysisOptions,
+  dependencyState: DependencyState
+): DependencyProfile {
+  const fileRelative = toRepoPath(filePath, options.root);
+  dependencyState.files.add(fileRelative);
+
+  const deps = collectModuleDependencies(sourceFile, filePath, options.root);
+  const importerIsTest = isTestFile(filePath);
+
+  for (const internalDependency of deps.internalDependencies) {
+    const normalizedDep = normalizeDependencyValue(internalDependency);
+    trackDependencyEdge(
+      dependencyState,
+      fileRelative,
+      normalizedDep,
+      importerIsTest
+    );
+  }
+
+  if (deps.externalDependencies.length > 0) {
+    dependencyState.externalCounts.set(
+      fileRelative,
+      new Set(deps.externalDependencies)
+    );
+  }
+
+  if (deps.unresolvedDependencies.length > 0) {
+    dependencyState.unresolvedCounts.set(
+      fileRelative,
+      new Set(deps.unresolvedDependencies)
+    );
+  }
+
+  dependencyState.declaredExportsByFile.set(fileRelative, deps.declaredExports);
+  dependencyState.importedSymbolsByFile.set(fileRelative, deps.importedSymbols);
+  dependencyState.reExportsByFile.set(fileRelative, deps.reExports);
+
+  return {
+    ...deps,
+    package: packageName,
+    file: fileRelative,
+  };
+}
+
+export function dependencyProfileToRecord(
+  fileRelative: string,
+  dependencyState: DependencyState
+): DependencyRecord {
+  const outbound = dependencyState.outgoing.get(fileRelative) || new Set();
+  const inbound = dependencyState.incoming.get(fileRelative) || new Set();
+  const prodIn =
+    dependencyState.incomingFromProduction.get(fileRelative) || new Set();
+  const testIn =
+    dependencyState.incomingFromTests.get(fileRelative) || new Set();
+  const external =
+    dependencyState.externalCounts.get(fileRelative) || new Set();
+  const unresolvedSet =
+    dependencyState.unresolvedCounts.get(fileRelative) || new Set();
+
+  return {
+    file: fileRelative,
+    outboundCount: outbound.size,
+    inboundCount: inbound.size,
+    inboundFromProduction: prodIn.size,
+    inboundFromTests: testIn.size,
+    externalDependencyCount: external.size,
+    unresolvedDependencyCount: unresolvedSet.size,
+  };
+}

package/skills/{octocode-code-engineer → octocode-engineer}/src/analysis/discovery.test.ts

@@ -190,6 +190,63 @@ describe('discovery', () => {
         [...basenames].sort((a, b) => a.localeCompare(b))
       );
     });
+
+    it('skips minified js artifacts', () => {
+      fs.writeFileSync(path.join(tmpDir, 'app.js'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'app.min.js'), '', 'utf8');
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files.some(f => f.endsWith('app.js'))).toBe(true);
+      expect(files.some(f => f.endsWith('app.min.js'))).toBe(false);
+    });
+
+    it('skips scripts files when mirrored src file exists', () => {
+      fs.mkdirSync(path.join(tmpDir, 'src'), { recursive: true });
+      fs.mkdirSync(path.join(tmpDir, 'scripts'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'src', 'index.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'scripts', 'index.js'), '', 'utf8');
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files.some(f => f.endsWith(path.join('src', 'index.ts')))).toBe(
+        true
+      );
+      expect(
+        files.some(f => f.endsWith(path.join('scripts', 'index.js')))
+      ).toBe(false);
+    });
+
+    it('keeps scripts files when no src mirror exists', () => {
+      fs.mkdirSync(path.join(tmpDir, 'scripts'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'scripts', 'bootstrap.js'), '', 'utf8');
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(
+        files.some(f => f.endsWith(path.join('scripts', 'bootstrap.js')))
+      ).toBe(true);
+    });
+
+    it('keeps scoped scripts file even when mirrored src file exists', () => {
+      fs.mkdirSync(path.join(tmpDir, 'src'), { recursive: true });
+      fs.mkdirSync(path.join(tmpDir, 'scripts'), { recursive: true });
+      const scriptPath = path.join(tmpDir, 'scripts', 'index.js');
+      fs.writeFileSync(path.join(tmpDir, 'src', 'index.ts'), '', 'utf8');
+      fs.writeFileSync(scriptPath, '', 'utf8');
+
+      const opts: AnalysisOptions = {
+        ...DEFAULT_OPTS,
+        root: tmpDir,
+        scope: [scriptPath],
+      };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files.some(f => f === scriptPath)).toBe(true);
+    });
   });
 
   describe('safeRead', () => {

package/skills/{octocode-code-engineer → octocode-engineer}/src/analysis/discovery.ts

@@ -6,6 +6,42 @@ import { ALLOWED_EXTS } from '../types/index.js';
 
 import type { AnalysisOptions, FileEntry, PackageInfo } from '../types/index.js';
 
+const SOURCE_MIRROR_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+
+function isExplicitlyScoped(
+  filePath: string,
+  scope: AnalysisOptions['scope']
+): boolean {
+  if (!scope || scope.length === 0) return false;
+  const normalizedFile = path.normalize(filePath);
+  return scope.some(scopeEntry => {
+    const normalizedScope = path.normalize(scopeEntry);
+    return (
+      normalizedFile === normalizedScope ||
+      normalizedFile.startsWith(normalizedScope + path.sep)
+    );
+  });
+}
+
+function isMinifiedArtifact(fileName: string): boolean {
+  return /\.min\.(?:js|mjs|cjs)$/i.test(fileName);
+}
+
+function hasSrcMirror(filePath: string, rootDir: string): boolean {
+  const rel = path.relative(rootDir, filePath);
+  if (!rel || rel.startsWith('..')) return false;
+  const parts = rel.split(path.sep);
+  if (parts[0] !== 'scripts' || parts.length < 2) return false;
+
+  const ext = path.extname(filePath);
+  const relWithoutExt = parts.slice(1).join(path.sep).slice(0, -ext.length);
+  for (const candidateExt of SOURCE_MIRROR_EXTS) {
+    const candidate = path.join(rootDir, 'src', `${relWithoutExt}${candidateExt}`);
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return true;
+  }
+  return false;
+}
+
 export function collectFiles(rootDir: string, opts: AnalysisOptions): string[] {
   const files: string[] = [];
   const walk = (dir: string): void => {
@@ -25,6 +61,13 @@ export function collectFiles(rootDir: string, opts: AnalysisOptions): string[] {
       if (!entry.isFile()) continue;
       if (entry.name.endsWith('.d.ts')) continue;
 
+      if (
+        !isExplicitlyScoped(next, opts.scope) &&
+        (isMinifiedArtifact(entry.name) || hasSrcMirror(next, rootDir))
+      ) {
+        continue;
+      }
+
       const ext = path.extname(entry.name);
       if (!ALLOWED_EXTS.has(ext)) continue;
       if (!opts.includeTests && isTestFile(next)) continue;

package/skills/{octocode-code-engineer → octocode-engineer}/src/ast/search.test.ts

@@ -645,3 +645,116 @@ describe('formatTextOutput with context', () => {
     expect(output).not.toContain('undefined');
   });
 });
+
+describe('new AST search presets', () => {
+  it('catch-rethrow: finds catch blocks that re-throw', () => {
+    const source = `
+try { doStuff(); } catch (e) { throw e; }
+try { doOther(); } catch (e) { console.error(e); throw e; }
+try { ok(); } catch (e) { handleError(e); }
+`;
+    const preset = PRESETS['catch-rethrow'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('catch-rethrow: no match when catch handles error', () => {
+    const source = `try { doStuff(); } catch (e) { handleError(e); }`;
+    const preset = PRESETS['catch-rethrow'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBe(0);
+  });
+
+  it('promise-all: finds Promise.all calls', () => {
+    const source = `
+const results = await Promise.all([fetch('/a'), fetch('/b')]);
+const single = await fetch('/c');
+`;
+    const preset = PRESETS['promise-all'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBe(1);
+  });
+
+  it('promise-all: no match without Promise.all', () => {
+    const source = `const x = await fetch('/a');`;
+    const preset = PRESETS['promise-all'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBe(0);
+  });
+
+  it('boolean-param: finds boolean-typed parameters', () => {
+    const source = `function toggle(visible: boolean, active: boolean) { return visible && active; }`;
+    const preset = PRESETS['boolean-param'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('boolean-param: no match for non-boolean params', () => {
+    const source = `function add(a: number, b: number) { return a + b; }`;
+    const preset = PRESETS['boolean-param'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBe(0);
+  });
+
+  it('magic-number: finds numeric literals excluding 0 and 1', () => {
+    const source = `
+const x = 42;
+const y = 0;
+const z = 1;
+const w = 100;
+`;
+    const preset = PRESETS['magic-number'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBe(2);
+    expect(matches.some(m => m.text === '42')).toBe(true);
+    expect(matches.some(m => m.text === '100')).toBe(true);
+  });
+
+  it('magic-number: no match for 0 and 1', () => {
+    const source = `const x = 0; const y = 1;`;
+    const preset = PRESETS['magic-number'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBe(0);
+  });
+
+  it('deep-callback: finds 3+ nested arrow functions', () => {
+    const source = `
+const f = () => {
+  return () => {
+    return () => {
+      return 42;
+    };
+  };
+};
+`;
+    const preset = PRESETS['deep-callback'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('deep-callback: no match for 2 levels', () => {
+    const source = `const f = () => { return () => { return 1; }; };`;
+    const preset = PRESETS['deep-callback'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBe(0);
+  });
+
+  it('unused-var: finds variable declarations without call expressions', () => {
+    const source = `
+const x = 42;
+const y = "hello";
+`;
+    const preset = PRESETS['unused-var'];
+    const matches = searchFile('test.ts', source, preset, null, 100);
+    expect(matches.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('all new presets are defined in PRESETS object', () => {
+    const newPresets = ['catch-rethrow', 'promise-all', 'boolean-param', 'magic-number', 'deep-callback', 'unused-var'];
+    for (const name of newPresets) {
+      expect(PRESETS[name]).toBeDefined();
+      expect(PRESETS[name].description).toBeTruthy();
+      expect(PRESETS[name].rule).toBeDefined();
+    }
+  });
+});

package/skills/{octocode-code-engineer → octocode-engineer}/src/ast/search.ts

@@ -181,6 +181,69 @@ export const PRESETS: Record<string, PresetRule> = {
     },
     description: 'Namespace imports (import * as X)',
   },
+  'catch-rethrow': {
+    rule: {
+      kind: 'catch_clause',
+      has: {
+        kind: 'statement_block',
+        has: {
+          kind: 'throw_statement',
+        },
+      },
+    },
+    description: 'Catch blocks that only re-throw the caught error',
+  },
+  'promise-all': {
+    rule: {
+      pattern: 'Promise.all($$$ARGS)',
+    },
+    description: 'Promise.all calls (check for missing error handling)',
+  },
+  'boolean-param': {
+    rule: {
+      kind: 'type_annotation',
+      has: {
+        kind: 'predefined_type',
+        regex: '^boolean$',
+      },
+    },
+    description: 'Function parameters typed as boolean',
+  },
+  'magic-number': {
+    rule: {
+      kind: 'number',
+      not: {
+        regex: '^[01]$',
+      },
+    },
+    description: 'Numeric literals (excluding 0 and 1) — potential magic numbers',
+  },
+  'deep-callback': {
+    rule: {
+      kind: 'arrow_function',
+      inside: {
+        kind: 'arrow_function',
+        inside: {
+          kind: 'arrow_function',
+          stopBy: 'end',
+        },
+        stopBy: 'end',
+      },
+    },
+    description: 'Deeply nested arrow function callbacks (3+ levels)',
+  },
+  'unused-var': {
+    rule: {
+      kind: 'variable_declarator',
+      not: {
+        has: {
+          kind: 'call_expression',
+          stopBy: 'end',
+        },
+      },
+    },
+    description: 'Variable declarations without call expressions (candidates for dead code)',
+  },
 };
 
 function isTestFile(filePath: string): boolean {
@@ -232,7 +295,7 @@ function parserForExt(ext: string): AstParser {
     case '.tsx':
       return astTsx;
     case '.jsx':
-      return astJs;
+      return astTsx;
     case '.js':
     case '.mjs':
     case '.cjs':