@renseiai/agentfactory-code-intelligence 0.8.16 → 0.8.18

package/dist/src/plugin/__tests__/plugin.test.js

@@ -5,9 +5,9 @@ describe('codeIntelligencePlugin', () => {
         expect(codeIntelligencePlugin.name).toBe('af-code-intelligence');
         expect(codeIntelligencePlugin.description).toBeTruthy();
     });
-    it('creates 4 tools', () => {
+    it('creates 6 tools', () => {
         const tools = codeIntelligencePlugin.createTools({ env: {}, cwd: '/tmp' });
-        expect(tools).toHaveLength(4);
+        expect(tools).toHaveLength(6);
     });
     it('creates tools with correct names', () => {
         const tools = codeIntelligencePlugin.createTools({ env: {}, cwd: '/tmp' });
@@ -16,6 +16,8 @@ describe('codeIntelligencePlugin', () => {
         expect(names).toContain('af_code_get_repo_map');
         expect(names).toContain('af_code_search_code');
         expect(names).toContain('af_code_check_duplicate');
+        expect(names).toContain('af_code_find_type_usages');
+        expect(names).toContain('af_code_validate_cross_deps');
     });
     it('tools have descriptions', () => {
         const tools = codeIntelligencePlugin.createTools({ env: {}, cwd: '/tmp' });

package/dist/src/plugin/code-intelligence-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-intelligence-plugin.d.ts","sourceRoot":"","sources":["../../../src/plugin/code-intelligence-plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AAchF,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAA;CACrE;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3B,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,2CAA2C;AAC3C,eAAO,MAAM,sBAAsB,EAAE,UAkHpC,CAAA"}
+{"version":3,"file":"code-intelligence-plugin.d.ts","sourceRoot":"","sources":["../../../src/plugin/code-intelligence-plugin.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AAchF,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAA;CACrE;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3B,GAAG,EAAE,MAAM,CAAA;CACZ;AAiOD,2CAA2C;AAC3C,eAAO,MAAM,sBAAsB,EAAE,UA6JpC,CAAA"}

package/dist/src/plugin/code-intelligence-plugin.js

@@ -1,3 +1,5 @@
+import { readFile, readdir, stat as fsStat } from 'node:fs/promises';
+import { join, extname, relative } from 'node:path';
 import { z } from 'zod';
 import { tool } from '@anthropic-ai/claude-agent-sdk';
 import { SymbolExtractor } from '../parser/symbol-extractor.js';
@@ -7,6 +9,188 @@ import { HybridSearchEngine } from '../search/hybrid-search.js';
 import { RepoMapGenerator } from '../repo-map/repo-map-generator.js';
 import { DedupPipeline } from '../memory/dedup-pipeline.js';
 import { InMemoryStore } from '../memory/memory-store.js';
+// ── Shared constants for file discovery ─────────────────────────────────────
+const SUPPORTED_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.go', '.rs',
+]);
+const IGNORE_DIRS = new Set([
+    'node_modules', 'dist', '.git', '.next', '.turbo',
+    'build', 'coverage', '__pycache__', '.agentfactory',
+    '.worktrees', 'vendor', 'target',
+]);
+async function discoverFiles(cwd) {
+    const files = new Map();
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile() && SUPPORTED_EXTENSIONS.has(extname(entry.name))) {
+                try {
+                    const s = await fsStat(fullPath);
+                    if (s.size > 512 * 1024)
+                        continue;
+                    const content = await readFile(fullPath, 'utf-8');
+                    files.set(relative(cwd, fullPath), content);
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    await walk(cwd);
+    return files;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+async function findTypeUsagesInProcess(cwd, typeName, maxResults) {
+    const files = await discoverFiles(cwd);
+    const usages = [];
+    const escaped = escapeRegex(typeName);
+    for (const [filePath, content] of files) {
+        if (!content.includes(typeName))
+            continue;
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.match(/\bimport\b/) && line.includes(typeName)) {
+                usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'import' });
+                continue;
+            }
+            if (/switch\s*\(/.test(line)) {
+                const windowEnd = Math.min(lines.length - 1, i + 50);
+                const window = lines.slice(i, windowEnd + 1).join('\n');
+                if (window.includes(typeName) || lines.slice(i, windowEnd + 1).some(l => /case\s+['"]/.test(l))) {
+                    // Check if the switch variable is typed as our target
+                    const switchWindow = lines.slice(Math.max(0, i - 5), i + 1).join('\n');
+                    if (switchWindow.includes(typeName) || window.includes(typeName)) {
+                        usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'switch_case' });
+                    }
+                }
+            }
+            if (new RegExp(`Record<\\s*${escaped}|satisfies\\s+Record<\\s*${escaped}`).test(line)) {
+                usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'mapping_object' });
+            }
+            if ((line.includes('assertNever') || line.includes('exhaustive')) && content.includes(typeName)) {
+                usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'exhaustive_check' });
+            }
+            if ((line.includes(`type ${typeName}`) || line.includes(`interface ${typeName}`) ||
+                new RegExp(`:\\s*${escaped}\\b`).test(line)) &&
+                !line.match(/\bimport\b/)) {
+                usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'type_reference' });
+            }
+        }
+    }
+    const kindPriority = {
+        switch_case: 0, mapping_object: 1, exhaustive_check: 2, type_reference: 3, import: 4,
+    };
+    usages.sort((a, b) => (kindPriority[a.kind] ?? 5) - (kindPriority[b.kind] ?? 5));
+    return {
+        typeName,
+        totalUsages: usages.length,
+        usages: usages.slice(0, maxResults),
+        switchStatements: usages.filter(u => u.kind === 'switch_case').length,
+        mappingObjects: usages.filter(u => u.kind === 'mapping_object').length,
+    };
+}
+// ── In-process cross-package dep validator ──────────────────────────────────
+async function validateCrossDepsInProcess(cwd, targetPath) {
+    const files = await discoverFiles(cwd);
+    // Discover workspace packages
+    const workspacePackages = new Map();
+    async function walkPkgs(dir, depth) {
+        if (depth > 5)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walkPkgs(fullPath, depth + 1);
+            }
+            else if (entry.name === 'package.json') {
+                try {
+                    const content = JSON.parse(await readFile(fullPath, 'utf-8'));
+                    if (content.name) {
+                        const allDeps = new Set([
+                            ...Object.keys(content.dependencies ?? {}),
+                            ...Object.keys(content.devDependencies ?? {}),
+                            ...Object.keys(content.peerDependencies ?? {}),
+                        ]);
+                        workspacePackages.set(relative(cwd, dir), { name: content.name, dir: relative(cwd, dir), deps: allDeps });
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    await walkPkgs(cwd, 0);
+    function findOwningPkg(filePath) {
+        let best = null;
+        for (const [dir, pkg] of workspacePackages) {
+            if (filePath.startsWith(dir + '/') || filePath === dir) {
+                if (!best || dir.length > best.key.length)
+                    best = { key: dir, pkg };
+            }
+        }
+        return best?.pkg;
+    }
+    const missingDeps = [];
+    let filesChecked = 0;
+    for (const [filePath, content] of files) {
+        if (targetPath && !filePath.startsWith(targetPath))
+            continue;
+        filesChecked++;
+        const owningPkg = findOwningPkg(filePath);
+        if (!owningPkg)
+            continue;
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const importMatch = lines[i].match(/(?:from\s+['"]|require\s*\(\s*['"]|import\s+['"])(@[^'"\/]+\/[^'"\/]+|[^.'"\/@][^'"\/]*)/);
+            if (!importMatch)
+                continue;
+            const importedPkg = importMatch[1];
+            const isWorkspacePkg = [...workspacePackages.values()].some(wp => wp.name === importedPkg);
+            if (!isWorkspacePkg)
+                continue;
+            if (!owningPkg.deps.has(importedPkg)) {
+                missingDeps.push({
+                    importingFile: filePath,
+                    importedPackage: importedPkg,
+                    packageJsonPath: join(owningPkg.dir, 'package.json'),
+                    line: i + 1,
+                });
+            }
+        }
+    }
+    const seen = new Set();
+    const uniqueMissing = missingDeps.filter(d => {
+        const key = `${d.packageJsonPath}:${d.importedPackage}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    return { valid: uniqueMissing.length === 0, missingDeps: uniqueMissing, packagesChecked: workspacePackages.size, filesChecked };
+}
 /** Create the code intelligence plugin. */
 export const codeIntelligencePlugin = {
     name: 'af-code-intelligence',
@@ -99,6 +283,39 @@ export const codeIntelligencePlugin = {
                     };
                 }
             }),
+            tool('af_code_find_type_usages', 'Find all switch/case statements, mapping objects, and usage sites for a union type or enum. Use this before adding new members to a type to identify all files that need updating.', {
+                type_name: z.string().describe('The type/enum name to search for (e.g. "AgentWorkType")'),
+                max_results: z.number().optional().describe('Maximum results (default 50)'),
+            }, async (args) => {
+                try {
+                    const result = await findTypeUsagesInProcess(context.cwd, args.type_name, args.max_results ?? 50);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                        isError: true,
+                    };
+                }
+            }),
+            tool('af_code_validate_cross_deps', 'Check that cross-package imports in a monorepo have corresponding package.json dependency declarations. Returns missing dependencies that would cause CI typecheck failures.', {
+                path: z.string().optional().describe('Optional directory/file to scope the check'),
+            }, async (args) => {
+                try {
+                    const result = await validateCrossDepsInProcess(context.cwd, args.path);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                        isError: true,
+                    };
+                }
+            }),
         ];
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renseiai/agentfactory-code-intelligence",
-  "version": "0.8.16",
+  "version": "0.8.18",
   "type": "module",
   "description": "Code intelligence for AgentFactory — tree-sitter AST parsing, BM25 search, incremental indexing, memory deduplication",
   "author": "Rensei AI (https://rensei.ai)",