@neurcode-ai/cli 0.9.44 → 0.9.45

package/dist/utils/diff-symbols.d.ts

@@ -0,0 +1,10 @@
+import type { DiffFile } from '@neurcode-ai/diff-parser';
+import type { ChangeContractDiffSymbolAction, ChangeContractSymbolType } from './change-contract';
+export interface DiffSymbolChange {
+    name: string;
+    type: ChangeContractSymbolType;
+    action: ChangeContractDiffSymbolAction;
+    file: string;
+}
+export declare function extractDeclaredSymbolsFromDiff(diffFiles: DiffFile[]): DiffSymbolChange[];
+//# sourceMappingURL=diff-symbols.d.ts.map

package/dist/utils/diff-symbols.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDeclaredSymbolsFromDiff = extractDeclaredSymbolsFromDiff;
+const SYMBOL_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.py',
+    '.go',
+]);
+function normalizeRepoPath(value) {
+    return value.replace(/\\/g, '/').replace(/^\.\//, '').trim();
+}
+function extname(filePath) {
+    const normalized = normalizeRepoPath(filePath);
+    const lastSlash = normalized.lastIndexOf('/');
+    const lastDot = normalized.lastIndexOf('.');
+    if (lastDot <= lastSlash)
+        return '';
+    return normalized.slice(lastDot).toLowerCase();
+}
+function isSymbolCandidateFile(filePath) {
+    const extension = extname(filePath);
+    return SYMBOL_EXTENSIONS.has(extension);
+}
+function normalizeSymbolName(value) {
+    return String(value || '')
+        .trim()
+        .replace(/^['"`]+|['"`]+$/g, '')
+        .replace(/\(\)\s*$/, '');
+}
+function isValidIdentifier(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+}
+function stripInlineComments(line) {
+    const hashIndex = line.indexOf('#');
+    if (hashIndex >= 0 && !/["'`]/.test(line.slice(0, hashIndex))) {
+        return line.slice(0, hashIndex);
+    }
+    const slashIndex = line.indexOf('//');
+    if (slashIndex >= 0) {
+        return line.slice(0, slashIndex);
+    }
+    return line;
+}
+const METHOD_RESERVED_NAMES = new Set([
+    'if',
+    'for',
+    'while',
+    'switch',
+    'catch',
+    'return',
+    'else',
+    'do',
+    'try',
+    'finally',
+    'throw',
+    'constructor',
+]);
+function extractDeclaredSymbolsFromLine(line) {
+    const sanitizedLine = stripInlineComments(line);
+    const matches = [];
+    const seen = new Set();
+    const push = (name, type) => {
+        const normalized = normalizeSymbolName(name);
+        if (!isValidIdentifier(normalized))
+            return;
+        const key = `${type}::${normalized}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        matches.push({ name: normalized, type });
+    };
+    const patternSpecs = [
+        {
+            type: 'class',
+            regex: /^\s*(?:export\s+)?(?:default\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)\b/,
+        },
+        {
+            type: 'class',
+            regex: /^\s*(?:export\s+)?default\s+class(?:\s+([A-Za-z_$][A-Za-z0-9_$]*))?\b/,
+            resolver: (match) => (match[1] ? match[1] : 'default'),
+        },
+        {
+            type: 'interface',
+            regex: /^\s*(?:export\s+)?interface\s+([A-Za-z_$][A-Za-z0-9_$]*)\b/,
+        },
+        {
+            type: 'type',
+            regex: /^\s*(?:export\s+)?type\s+([A-Za-z_$][A-Za-z0-9_$]*)\b/,
+        },
+        {
+            type: 'function',
+            regex: /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/,
+        },
+        {
+            type: 'function',
+            regex: /^\s*(?:export\s+)?default\s+(?:async\s+)?function\s*\(/,
+            resolver: () => 'default',
+        },
+        {
+            type: 'function',
+            regex: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>/,
+        },
+        {
+            type: 'function',
+            regex: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?function\b/,
+        },
+        {
+            type: 'method',
+            regex: /^\s*(?:public|private|protected|readonly|static|async|get|set|\s)*([A-Za-z_$][A-Za-z0-9_$]*)\s*\([^;{}]*\)\s*\{/,
+            resolver: (match) => {
+                const candidate = match[1] || null;
+                if (!candidate)
+                    return null;
+                if (METHOD_RESERVED_NAMES.has(candidate))
+                    return null;
+                return candidate;
+            },
+        },
+        {
+            type: 'method',
+            regex: /^\s*(?:public|private|protected|readonly|static)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>/,
+        },
+        {
+            type: 'class',
+            regex: /^\s*class\s+([A-Za-z_][A-Za-z0-9_]*)\s*[\(:]/,
+        },
+        {
+            type: 'function',
+            regex: /^\s*def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/,
+        },
+        {
+            type: 'function',
+            regex: /^\s*func\s+(?:\([^)]+\)\s*)?([A-Za-z_][A-Za-z0-9_]*)\s*\(/,
+        },
+    ];
+    for (const spec of patternSpecs) {
+        const match = sanitizedLine.match(spec.regex);
+        if (!match)
+            continue;
+        const resolved = spec.resolver ? spec.resolver(match) : match[1] || null;
+        if (resolved) {
+            push(resolved, spec.type);
+        }
+    }
+    return matches;
+}
+function extractDeclaredSymbolsFromDiff(diffFiles) {
+    const counters = new Map();
+    for (const file of diffFiles) {
+        const normalizedPath = normalizeRepoPath(file.path);
+        if (!normalizedPath || !isSymbolCandidateFile(normalizedPath))
+            continue;
+        for (const hunk of file.hunks || []) {
+            const hasDelta = (hunk.lines || []).some((line) => line.type === 'added' || line.type === 'removed');
+            if (!hasDelta)
+                continue;
+            for (const line of hunk.lines || []) {
+                if (line.type !== 'added' && line.type !== 'removed' && line.type !== 'context')
+                    continue;
+                const declared = extractDeclaredSymbolsFromLine(line.content);
+                if (declared.length === 0)
+                    continue;
+                for (const symbol of declared) {
+                    const key = `${normalizedPath}::${symbol.type}::${symbol.name}`;
+                    const current = counters.get(key) || {
+                        file: normalizedPath,
+                        name: symbol.name,
+                        type: symbol.type,
+                        added: 0,
+                        removed: 0,
+                        context: 0,
+                    };
+                    if (line.type === 'added')
+                        current.added += 1;
+                    if (line.type === 'removed')
+                        current.removed += 1;
+                    if (line.type === 'context')
+                        current.context += 1;
+                    counters.set(key, current);
+                }
+            }
+        }
+    }
+    const changes = [];
+    for (const item of counters.values()) {
+        let action = 'delete';
+        if (item.added > 0 && item.removed > 0) {
+            action = 'modify';
+        }
+        else if (item.added > 0) {
+            action = 'add';
+        }
+        else if (item.removed === 0 && item.context > 0) {
+            action = 'modify';
+        }
+        changes.push({
+            name: item.name,
+            type: item.type,
+            action,
+            file: item.file,
+        });
+    }
+    return changes.sort((a, b) => {
+        if (a.file !== b.file)
+            return a.file.localeCompare(b.file);
+        if (a.name !== b.name)
+            return a.name.localeCompare(b.name);
+        return a.type.localeCompare(b.type);
+    });
+}
+//# sourceMappingURL=diff-symbols.js.map

package/dist/utils/plan-symbols.d.ts

@@ -0,0 +1,17 @@
+import type { ChangeContractExpectedSymbol, ChangeContractSymbolAction } from './change-contract';
+interface PlanFileLike {
+    path: string;
+    action: ChangeContractSymbolAction;
+    reason?: string;
+    suggestion?: string;
+    rationale?: string;
+}
+export interface PlanLike {
+    summary?: string;
+    recommendations?: string[];
+    files?: PlanFileLike[];
+    symbols?: unknown;
+}
+export declare function mapPlanSymbolsForChangeContract(plan: PlanLike): ChangeContractExpectedSymbol[];
+export {};
+//# sourceMappingURL=plan-symbols.d.ts.map

package/dist/utils/plan-symbols.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapPlanSymbolsForChangeContract = mapPlanSymbolsForChangeContract;
+function normalizeRepoPath(value) {
+    return value.replace(/\\/g, '/').replace(/^\.\//, '').trim();
+}
+function normalizeSymbolName(value) {
+    return String(value || '')
+        .trim()
+        .replace(/^['"`]+|['"`]+$/g, '')
+        .replace(/\(\)\s*$/, '');
+}
+function normalizeSymbolType(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'function'
+        || normalized === 'class'
+        || normalized === 'interface'
+        || normalized === 'type'
+        || normalized === 'method'
+        || normalized === 'const'
+        || normalized === 'unknown') {
+        return normalized;
+    }
+    if (normalized === 'fn')
+        return 'function';
+    if (normalized === 'var' || normalized === 'variable')
+        return 'const';
+    return undefined;
+}
+function normalizeSymbolAction(value, fallback) {
+    const normalized = String(value || '').trim().toUpperCase();
+    if (normalized === 'CREATE' || normalized === 'MODIFY' || normalized === 'BLOCK') {
+        return normalized;
+    }
+    return fallback;
+}
+function extractSymbolMentionsFromText(text) {
+    if (!text || !text.trim())
+        return [];
+    const entries = [];
+    const seen = new Set();
+    const push = (name, type) => {
+        const normalizedName = normalizeSymbolName(name);
+        if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(normalizedName))
+            return;
+        if (normalizedName.length > 80)
+            return;
+        const key = `${type || 'unknown'}::${normalizedName}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        entries.push({
+            name: normalizedName,
+            ...(type ? { type } : {}),
+        });
+    };
+    for (const match of text.matchAll(/`([A-Za-z_$][A-Za-z0-9_$]*)`/g)) {
+        if (match[1]) {
+            push(match[1]);
+        }
+    }
+    for (const match of text.matchAll(/\b(function|class|interface|type|method|handler)\s+`?([A-Za-z_$][A-Za-z0-9_$]*)`?/gi)) {
+        const keyword = String(match[1] || '').toLowerCase();
+        const candidate = match[2];
+        if (!candidate)
+            continue;
+        const type = keyword === 'class'
+            ? 'class'
+            : keyword === 'interface'
+                ? 'interface'
+                : keyword === 'type'
+                    ? 'type'
+                    : keyword === 'method' || keyword === 'handler'
+                        ? 'method'
+                        : 'function';
+        push(candidate, type);
+    }
+    return entries;
+}
+function parseExplicitSymbols(rawSymbols) {
+    if (!Array.isArray(rawSymbols))
+        return [];
+    const parsed = [];
+    for (const entry of rawSymbols) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const symbol = entry;
+        const name = normalizeSymbolName(String(symbol.name || ''));
+        if (!name)
+            continue;
+        const action = normalizeSymbolAction(typeof symbol.action === 'string' ? symbol.action : undefined, 'MODIFY');
+        const type = normalizeSymbolType(typeof symbol.type === 'string' ? symbol.type : undefined);
+        const file = typeof symbol.file === 'string' && symbol.file.trim()
+            ? normalizeRepoPath(symbol.file)
+            : undefined;
+        const reason = typeof symbol.reason === 'string' && symbol.reason.trim()
+            ? symbol.reason.trim().slice(0, 240)
+            : undefined;
+        parsed.push({
+            name,
+            action,
+            ...(type ? { type } : {}),
+            ...(file ? { file } : {}),
+            ...(reason ? { reason } : {}),
+        });
+    }
+    return parsed;
+}
+function mergeExpectedSymbols(items) {
+    const precedence = {
+        MODIFY: 1,
+        CREATE: 2,
+        BLOCK: 3,
+    };
+    const merged = new Map();
+    for (const item of items) {
+        const name = normalizeSymbolName(item.name);
+        if (!name)
+            continue;
+        const type = normalizeSymbolType(item.type);
+        const file = item.file ? normalizeRepoPath(item.file) : undefined;
+        const key = `${file || '*'}::${type || 'unknown'}::${name}`;
+        const reason = item.reason ? item.reason.trim().slice(0, 240) : undefined;
+        const candidate = {
+            name,
+            action: item.action,
+            ...(type ? { type } : {}),
+            ...(file ? { file } : {}),
+            ...(reason ? { reason } : {}),
+        };
+        const existing = merged.get(key);
+        if (!existing) {
+            merged.set(key, candidate);
+            continue;
+        }
+        if (precedence[candidate.action] > precedence[existing.action]) {
+            merged.set(key, candidate);
+            continue;
+        }
+        if (!existing.reason && candidate.reason) {
+            merged.set(key, {
+                ...existing,
+                reason: candidate.reason,
+            });
+        }
+    }
+    return [...merged.values()].sort((a, b) => {
+        const fileA = a.file || '';
+        const fileB = b.file || '';
+        if (fileA !== fileB)
+            return fileA.localeCompare(fileB);
+        if (a.name !== b.name)
+            return a.name.localeCompare(b.name);
+        return (a.type || '').localeCompare(b.type || '');
+    });
+}
+function mapPlanSymbolsForChangeContract(plan) {
+    const result = [];
+    const files = Array.isArray(plan.files) ? plan.files : [];
+    result.push(...parseExplicitSymbols(plan.symbols));
+    for (const file of files) {
+        const filePath = normalizeRepoPath(String(file.path || ''));
+        if (!filePath)
+            continue;
+        const action = normalizeSymbolAction(file.action, 'MODIFY');
+        const textSources = [file.reason, file.suggestion, file.rationale];
+        for (const source of textSources) {
+            if (!source || !source.trim())
+                continue;
+            for (const symbol of extractSymbolMentionsFromText(source)) {
+                result.push({
+                    name: symbol.name,
+                    action,
+                    file: filePath,
+                    ...(symbol.type ? { type: symbol.type } : {}),
+                    reason: `Derived from plan note for ${filePath}`,
+                });
+            }
+        }
+    }
+    if (typeof plan.summary === 'string' && plan.summary.trim()) {
+        for (const symbol of extractSymbolMentionsFromText(plan.summary)) {
+            result.push({
+                name: symbol.name,
+                action: 'MODIFY',
+                ...(symbol.type ? { type: symbol.type } : {}),
+                reason: 'Derived from plan summary',
+            });
+        }
+    }
+    if (Array.isArray(plan.recommendations)) {
+        for (const recommendation of plan.recommendations) {
+            if (!recommendation || !recommendation.trim())
+                continue;
+            for (const symbol of extractSymbolMentionsFromText(recommendation)) {
+                result.push({
+                    name: symbol.name,
+                    action: 'MODIFY',
+                    ...(symbol.type ? { type: symbol.type } : {}),
+                    reason: 'Derived from plan recommendations',
+                });
+            }
+        }
+    }
+    return mergeExpectedSymbols(result);
+}
+//# sourceMappingURL=plan-symbols.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neurcode-ai/cli",
-  "version": "0.9.44",
+  "version": "0.9.45",
   "description": "Neurcode CLI - AI code governance and diff analysis",
   "bin": {
     "neurcode": "dist/index.js"
@@ -11,6 +11,10 @@
     "dist",
     "README.md"
   ],
+  "scripts": {
+    "start": "node dist/index.js",
+    "help": "node dist/index.js --help"
+  },
   "keywords": [
     "cli",
     "code-governance",
@@ -54,17 +58,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
-    "@types/glob": "^8.1.0",
-    "@types/node": "^20.10.0",
-    "@types/uuid": "^9.0.8",
-    "typescript": "^5.3.0"
-  },
-  "scripts": {
-    "build": "rm -rf dist && tsc && chmod +x dist/index.js",
-    "dev": "tsc --watch",
-    "start": "node dist/index.js"
   }
-}
+}