@renseiai/agentfactory-cli 0.8.17 → 0.8.19

package/dist/src/code.d.ts

@@ -13,6 +13,8 @@
  *   get-repo-map             Get PageRank-ranked repository file map
  *   search-code <query>      BM25/hybrid code search
  *   check-duplicate          Check content for duplicates
+ *   find-type-usages <name>  Find all switch/case, mapping, and usage sites for a type
+ *   validate-cross-deps      Check cross-package imports have package.json entries
  *   help                     Show this help message
  *
  * Environment:

package/dist/src/code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code.d.ts","sourceRoot":"","sources":["../../src/code.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;GAmBG"}
+{"version":3,"file":"code.d.ts","sourceRoot":"","sources":["../../src/code.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/src/code.js

@@ -13,6 +13,8 @@
  *   get-repo-map             Get PageRank-ranked repository file map
  *   search-code <query>      BM25/hybrid code search
  *   check-duplicate          Check content for duplicates
+ *   find-type-usages <name>  Find all switch/case, mapping, and usage sites for a type
+ *   validate-cross-deps      Check cross-package imports have package.json entries
  *   help                     Show this help message
  *
  * Environment:
@@ -55,6 +57,12 @@ Options (check-duplicate):
   --content <string>          Content to check (inline)
   --content-file <path>       Path to file containing content to check
 
+Options (find-type-usages):
+  --max-results <N>           Maximum results (default: 50)
+
+Options (validate-cross-deps):
+  [path]                      Optional directory/file to scope the check
+
 Index:
   First invocation builds the index from source files (~5-10s).
   Subsequent calls reuse the persisted index from .agentfactory/code-index/.
@@ -66,6 +74,9 @@ Examples:
   af-code search-code "incremental indexer" --language typescript
   af-code check-duplicate --content "function hello() { return 'world' }"
   af-code check-duplicate --content-file /tmp/snippet.ts
+  af-code find-type-usages "AgentWorkType"
+  af-code validate-cross-deps
+  af-code validate-cross-deps packages/linear
 `);
 }
 async function main() {

package/dist/src/lib/code-intelligence-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-intelligence-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/code-intelligence-runner.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,OAAO,CAAA;CAChB;AAID,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAC7C,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;CACzB,CAwBA;AAgLD,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,4BAA4B,GACnC,OAAO,CAAC,4BAA4B,CAAC,CAevC"}
+{"version":3,"file":"code-intelligence-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/code-intelligence-runner.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,OAAO,CAAA;CAChB;AAID,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAC7C,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;CACzB,CAwBA;AA+gBD,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,4BAA4B,GACnC,OAAO,CAAC,4BAA4B,CAAC,CAuBvC"}

package/dist/src/lib/code-intelligence-runner.js

@@ -171,8 +171,290 @@ async function checkDuplicate(config, engines) {
     const result = await engines.dedupPipeline.check(content);
     return result;
 }
+async function findTypeUsages(config) {
+    const typeName = config.positionalArgs[0];
+    if (!typeName)
+        throw new Error('Usage: af-code find-type-usages <TypeName>');
+    const maxResults = config.args['max-results'] ? Number(config.args['max-results']) : 50;
+    const files = await discoverSourceFiles(config.cwd);
+    const usages = [];
+    // Patterns that indicate exhaustive switch/case, mapping objects, or type references
+    const switchPattern = new RegExp(`switch\\s*\\(`, 'g');
+    const casePattern = new RegExp(`case\\s+['"]`, 'g');
+    const importPattern = new RegExp(`\\b${escapeRegex(typeName)}\\b`, 'g');
+    const mappingPattern = new RegExp(`(?:Record<\\s*${escapeRegex(typeName)}|:\\s*\\{\\s*\\[\\w+\\s+in\\s+${escapeRegex(typeName)}\\]|satisfies\\s+Record<\\s*${escapeRegex(typeName)})`, 'g');
+    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];
+            // Check for import of the type
+            if (line.match(/\bimport\b/) && line.includes(typeName)) {
+                usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'import' });
+                continue;
+            }
+            // Check for switch statements — look for switch keyword near the type name usage
+            if (switchPattern.test(line)) {
+                // Scan surrounding lines for the type name
+                const windowStart = Math.max(0, i - 2);
+                const windowEnd = Math.min(lines.length - 1, i + 5);
+                const window = lines.slice(windowStart, windowEnd + 1).join('\n');
+                if (window.includes(typeName) || hasRelatedCases(lines, i, typeName)) {
+                    usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'switch_case' });
+                }
+                switchPattern.lastIndex = 0;
+            }
+            // Check for Record<TypeName, ...> or mapping objects
+            if (mappingPattern.test(line)) {
+                usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'mapping_object' });
+                mappingPattern.lastIndex = 0;
+            }
+            // Check for exhaustive checks (assertNever, default: throw, etc.)
+            if ((line.includes('assertNever') || line.includes('exhaustive')) &&
+                content.includes(typeName)) {
+                usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'exhaustive_check' });
+            }
+            // Check for type definition/reference (union type definitions, extends, etc.)
+            if ((line.includes(`type ${typeName}`) ||
+                line.includes(`interface ${typeName}`) ||
+                line.match(new RegExp(`:\\s*${escapeRegex(typeName)}\\b`))) &&
+                !line.match(/\bimport\b/)) {
+                usages.push({ filePath, line: i + 1, context: line.trim(), kind: 'type_reference' });
+            }
+        }
+    }
+    // Deduplicate and sort: switch_case and mapping_object first (most actionable)
+    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,
+    };
+}
+/** Check if a switch block's case statements relate to a union type */
+function hasRelatedCases(lines, switchLine, _typeName) {
+    // Scan forward from the switch line looking for string literal cases
+    for (let j = switchLine; j < Math.min(lines.length, switchLine + 50); j++) {
+        if (lines[j].includes('case \'') || lines[j].includes('case "')) {
+            return true; // Has string literal cases, likely a discriminated union switch
+        }
+        if (lines[j].match(/^\s*\}/))
+            break; // End of block
+    }
+    return false;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Determine whether a line contains a real import statement (not one inside
+ * a comment, string literal, template literal, or test assertion).
+ *
+ * The caller must maintain the parse state across lines.
+ */
+function isRealImportLine(line, state) {
+    const trimmed = line.trim();
+    // Track block comment boundaries
+    if (state.inBlockComment) {
+        if (trimmed.includes('*/')) {
+            return { real: false, state: { ...state, inBlockComment: false } };
+        }
+        return { real: false, state };
+    }
+    if (trimmed.startsWith('/*')) {
+        const closesOnSameLine = trimmed.includes('*/');
+        return { real: false, state: { ...state, inBlockComment: !closesOnSameLine } };
+    }
+    // Track template literal boundaries (backtick strings spanning multiple lines)
+    // Count unescaped backticks to toggle state
+    if (state.inTemplateLiteral) {
+        const backtickCount = countUnescapedBackticks(line);
+        if (backtickCount % 2 === 1) {
+            // Odd number of backticks — template literal ends on this line
+            return { real: false, state: { ...state, inTemplateLiteral: false } };
+        }
+        return { real: false, state };
+    }
+    // Single-line comments and JSDoc continuation lines
+    if (trimmed.startsWith('//') || trimmed.startsWith('*'))
+        return { real: false, state };
+    // Check if this line opens a template literal that doesn't close on the same line
+    const backticks = countUnescapedBackticks(line);
+    if (backticks % 2 === 1) {
+        // Odd backticks — a template literal opens and doesn't close on this line.
+        // The import on this line (if any) could be before or after the backtick.
+        // If the import keyword appears after a backtick, it's template content.
+        const importIdx = line.search(/\b(import|export)\s/);
+        const firstBacktick = line.indexOf('`');
+        if (importIdx >= 0 && firstBacktick >= 0 && importIdx > firstBacktick) {
+            // Import appears inside the template literal
+            return { real: false, state: { ...state, inTemplateLiteral: true } };
+        }
+        // Import appears before the backtick — real import, but template opens
+        if (importIdx >= 0 && (firstBacktick < 0 || importIdx < firstBacktick)) {
+            return { real: true, state: { ...state, inTemplateLiteral: true } };
+        }
+        return { real: false, state: { ...state, inTemplateLiteral: true } };
+    }
+    // Real import/export/require statements start at the beginning of the line
+    if (/^\s*(import|export)\s/.test(line))
+        return { real: true, state };
+    // Dynamic require: `const x = require('pkg')`
+    if (/\brequire\s*\(/.test(line)) {
+        const reqIdx = line.indexOf('require');
+        const beforeReq = line.slice(0, reqIdx);
+        if (beforeReq.includes('`') || beforeReq.includes("'require") || beforeReq.includes('"require')) {
+            return { real: false, state };
+        }
+        return { real: true, state };
+    }
+    return { real: false, state };
+}
+/** Count unescaped backticks in a line */
+function countUnescapedBackticks(line) {
+    let count = 0;
+    for (let i = 0; i < line.length; i++) {
+        if (line[i] === '`' && (i === 0 || line[i - 1] !== '\\')) {
+            count++;
+        }
+    }
+    return count;
+}
+async function validateCrossDeps(config) {
+    const targetPath = config.positionalArgs[0]; // Optional: specific file or directory
+    const files = await discoverSourceFiles(config.cwd);
+    // 1. Build a map of workspace packages by reading all package.json files
+    const workspacePackages = new Map();
+    await discoverWorkspacePackages(config.cwd, workspacePackages);
+    // 2. Map file paths to their owning workspace package
+    function findOwningPackage(filePath) {
+        let bestMatch = null;
+        for (const [dir, pkg] of workspacePackages) {
+            if (filePath.startsWith(dir + '/') || filePath === dir) {
+                if (!bestMatch || dir.length > bestMatch.key.length) {
+                    bestMatch = { key: dir, pkg };
+                }
+            }
+        }
+        return bestMatch?.pkg;
+    }
+    const missingDeps = [];
+    // 3. Check each file for cross-package imports
+    for (const [filePath, content] of files) {
+        if (targetPath && !filePath.startsWith(targetPath))
+            continue;
+        const owningPkg = findOwningPackage(filePath);
+        if (!owningPkg)
+            continue;
+        const lines = content.split('\n');
+        let parseState = { inBlockComment: false, inTemplateLiteral: false };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip comments, string literals, and template content
+            const classification = isRealImportLine(line, parseState);
+            parseState = classification.state;
+            if (!classification.real)
+                continue;
+            // Match import/require of workspace packages
+            const importMatch = line.match(/(?:from\s+['"]|require\s*\(\s*['"]|import\s+['"])(@[^'"\/]+\/[^'"\/]+|[^.'"\/@][^'"\/]*)/);
+            if (!importMatch)
+                continue;
+            const importedPkg = importMatch[1];
+            // Check if this is a workspace package
+            const isWorkspacePkg = [...workspacePackages.values()].some(wp => wp.name === importedPkg);
+            if (!isWorkspacePkg)
+                continue;
+            // Check if it's declared in package.json
+            if (!owningPkg.deps.has(importedPkg)) {
+                missingDeps.push({
+                    importingFile: filePath,
+                    importedPackage: importedPkg,
+                    packageJsonPath: join(owningPkg.dir, 'package.json'),
+                    line: i + 1,
+                });
+            }
+        }
+    }
+    // Deduplicate by (packageJsonPath, importedPackage)
+    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: targetPath
+            ? [...files.keys()].filter(f => f.startsWith(targetPath)).length
+            : files.size,
+    };
+}
+async function discoverWorkspacePackages(cwd, result) {
+    // Find all package.json files in the workspace (skip node_modules, dist)
+    async function walk(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 walk(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 ?? {}),
+                        ]);
+                        result.set(relative(cwd, dir), {
+                            name: content.name,
+                            dir: relative(cwd, dir),
+                            deps: allDeps,
+                        });
+                    }
+                }
+                catch {
+                    // Skip malformed package.json
+                }
+            }
+        }
+    }
+    await walk(cwd, 0);
+}
 // ── Main runner ─────────────────────────────────────────────────────────────
 export async function runCodeIntelligence(config) {
+    // Commands that don't need the full index
+    switch (config.command) {
+        case 'find-type-usages':
+            return { output: await findTypeUsages(config) };
+        case 'validate-cross-deps':
+            return { output: await validateCrossDeps(config) };
+    }
     const engines = await initializeIndex(config.cwd);
     switch (config.command) {
         case 'search-symbols':
@@ -184,6 +466,6 @@ export async function runCodeIntelligence(config) {
         case 'check-duplicate':
             return { output: await checkDuplicate(config, engines) };
         default:
-            throw new Error(`Unknown command: ${config.command}. Available: search-symbols, get-repo-map, search-code, check-duplicate`);
+            throw new Error(`Unknown command: ${config.command}. Available: search-symbols, get-repo-map, search-code, check-duplicate, find-type-usages, validate-cross-deps`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renseiai/agentfactory-cli",
-  "version": "0.8.17",
+  "version": "0.8.19",
   "type": "module",
   "description": "CLI tools for AgentFactory — local orchestrator, remote worker, queue admin",
   "author": "Rensei AI (https://rensei.ai)",
@@ -126,12 +126,12 @@
   ],
   "dependencies": {
     "dotenv": "^17.2.3",
-    "@renseiai/agentfactory": "0.8.17",
-    "@renseiai/plugin-linear": "0.8.17",
-    "@renseiai/agentfactory-server": "0.8.17"
+    "@renseiai/plugin-linear": "0.8.19",
+    "@renseiai/agentfactory-server": "0.8.19",
+    "@renseiai/agentfactory": "0.8.19"
   },
   "optionalDependencies": {
-    "@renseiai/agentfactory-code-intelligence": "0.8.17"
+    "@renseiai/agentfactory-code-intelligence": "0.8.19"
   },
   "devDependencies": {
     "@types/node": "^22.5.4",