closed-loop-cli 1.0.0

package/dist/tools/indexer.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCodeIndex = generateCodeIndex;
+exports.getDependents = getDependents;
+exports.queryCodeIndex = queryCodeIndex;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+/**
+ * Resolves relative module import paths to standardized workspace-relative paths.
+ */
+function resolveImportPath(fromFile, importPath, workspaceRoot = process.cwd()) {
+    const fromDir = path.dirname(path.join(workspaceRoot, fromFile));
+    const absoluteTarget = path.resolve(fromDir, importPath);
+    const relativeTarget = path.relative(workspaceRoot, absoluteTarget).replace(/\\/g, '/');
+    // Try standard file extensions
+    const extensions = ['.ts', '.js', '/index.ts', '/index.js'];
+    for (const ext of extensions) {
+        const targetWithExt = absoluteTarget + ext;
+        if (fs.existsSync(targetWithExt)) {
+            return (relativeTarget + ext).replace(/\/index\.(ts|js)$/, '');
+        }
+    }
+    // If file exists as-is
+    if (fs.existsSync(absoluteTarget)) {
+        return relativeTarget;
+    }
+    // Fallback target path
+    return relativeTarget + '.ts';
+}
+/**
+ * Generates the code index database and writes it to code-index.json.
+ */
+function generateCodeIndex(workspaceRoot = process.cwd()) {
+    const index = [];
+    function walk(currentDir) {
+        const files = fs.readdirSync(currentDir);
+        for (const file of files) {
+            const fullPath = path.join(currentDir, file);
+            // Skip ignorable folders
+            if (file === 'node_modules' || file === '.git' || file === 'dist' || file === '.gemini') {
+                continue;
+            }
+            const stats = fs.statSync(fullPath);
+            if (stats.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (stats.isFile()) {
+                const ext = path.extname(file).toLowerCase();
+                if (ext === '.ts' || ext === '.js') {
+                    const relativePath = path.relative(workspaceRoot, fullPath).replace(/\\/g, '/');
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const fileIndex = parseFileAST(relativePath, content);
+                    index.push(fileIndex);
+                }
+            }
+        }
+    }
+    walk(workspaceRoot);
+    const indexPath = path.join(workspaceRoot, 'code-index.json');
+    fs.writeFileSync(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+    return index;
+}
+/**
+ * Parses file AST to extract structured metadata.
+ */
+function parseFileAST(filePath, content) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const fileIndex = {
+        filePath,
+        classes: [],
+        interfaces: [],
+        functions: [],
+        imports: [],
+        exports: []
+    };
+    let currentClass = null;
+    function visit(node) {
+        const isExport = (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) || false;
+        // Capture Imports
+        if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
+            if (ts.isStringLiteral(node.moduleSpecifier)) {
+                const importPath = node.moduleSpecifier.text;
+                if (importPath.startsWith('.')) {
+                    const resolved = resolveImportPath(filePath, importPath);
+                    if (resolved) {
+                        fileIndex.imports.push(resolved);
+                    }
+                }
+                else {
+                    fileIndex.imports.push(importPath); // NPM library import
+                }
+            }
+        }
+        // Capture Named and Default Export statements
+        if (ts.isExportDeclaration(node)) {
+            if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+                for (const element of node.exportClause.elements) {
+                    fileIndex.exports.push(element.name.text);
+                }
+            }
+        }
+        else if (ts.isExportAssignment(node)) {
+            fileIndex.exports.push('default');
+        }
+        // Capture Classes and Methods
+        if (ts.isClassDeclaration(node) && node.name) {
+            if (isExport) {
+                fileIndex.exports.push(node.name.text);
+            }
+            const classObj = {
+                name: node.name.text,
+                methods: []
+            };
+            fileIndex.classes.push(classObj);
+            const oldClass = currentClass;
+            currentClass = classObj;
+            ts.forEachChild(node, visit);
+            currentClass = oldClass;
+        }
+        else if (ts.isInterfaceDeclaration(node) && node.name) {
+            if (isExport) {
+                fileIndex.exports.push(node.name.text);
+            }
+            fileIndex.interfaces.push({ name: node.name.text });
+        }
+        else if (ts.isFunctionDeclaration(node) && node.name) {
+            if (isExport) {
+                fileIndex.exports.push(node.name.text);
+            }
+            const isAsync = (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) || false;
+            const params = node.parameters.map(p => p.name.getText(sourceFile));
+            fileIndex.functions.push({
+                name: node.name.text,
+                isAsync,
+                parameters: params
+            });
+        }
+        else if (ts.isVariableStatement(node)) {
+            if (isExport) {
+                for (const decl of node.declarationList.declarations) {
+                    fileIndex.exports.push(decl.name.getText(sourceFile));
+                }
+            }
+            for (const decl of node.declarationList.declarations) {
+                if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+                    const func = decl.initializer;
+                    const isAsync = (func.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) || false;
+                    const params = func.parameters.map(p => p.name.getText(sourceFile));
+                    fileIndex.functions.push({
+                        name: decl.name.getText(sourceFile),
+                        isAsync,
+                        parameters: params
+                    });
+                }
+            }
+        }
+        else if (currentClass && ts.isMethodDeclaration(node) && node.name) {
+            const isAsync = (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) || false;
+            const isStatic = (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) || false;
+            const params = node.parameters.map(p => p.name.getText(sourceFile));
+            currentClass.methods.push({
+                name: node.name.getText(sourceFile),
+                isStatic,
+                isAsync,
+                parameters: params
+            });
+        }
+        else {
+            ts.forEachChild(node, visit);
+        }
+    }
+    ts.forEachChild(sourceFile, visit);
+    return fileIndex;
+}
+/**
+ * Queries code-index.json to find all files that import a given target file.
+ */
+function getDependents(targetFile, workspaceRoot = process.cwd()) {
+    const indexPath = path.join(workspaceRoot, 'code-index.json');
+    if (!fs.existsSync(indexPath)) {
+        return [];
+    }
+    let index = [];
+    try {
+        index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+    }
+    catch (e) {
+        return [];
+    }
+    const targetNormalized = targetFile.replace(/\\/g, '/').replace(/^\.\//, '');
+    const targetBase = targetNormalized.replace(/\.(ts|js)$/, '');
+    const dependents = [];
+    for (const file of index) {
+        const hasImport = file.imports.some(imp => {
+            const impNormalized = imp.replace(/\.(ts|js)$/, '');
+            return impNormalized === targetBase || impNormalized === targetNormalized;
+        });
+        if (hasImport && file.filePath !== targetNormalized) {
+            dependents.push(file.filePath);
+        }
+    }
+    return dependents;
+}
+/**
+ * Queries the code-index.json database for keyword matches.
+ */
+function queryCodeIndex(query, workspaceRoot = process.cwd()) {
+    const indexPath = path.join(workspaceRoot, 'code-index.json');
+    if (!fs.existsSync(indexPath)) {
+        generateCodeIndex(workspaceRoot);
+    }
+    let index = [];
+    try {
+        index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+    }
+    catch (e) {
+        return `Error reading code-index.json: ${e.message}`;
+    }
+    const queryLower = query.toLowerCase();
+    const matches = [];
+    for (const file of index) {
+        let fileHasMatch = false;
+        const fileLines = [];
+        // Check class names and methods
+        for (const cls of file.classes) {
+            let classMatched = cls.name.toLowerCase().includes(queryLower);
+            const matchedMethods = cls.methods.filter(m => m.name.toLowerCase().includes(queryLower));
+            if (classMatched || matchedMethods.length > 0) {
+                fileHasMatch = true;
+                fileLines.push(`  class ${cls.name}`);
+                for (const m of cls.methods) {
+                    const isMatched = m.name.toLowerCase().includes(queryLower);
+                    const highlight = isMatched ? ' <-- MATCH' : '';
+                    fileLines.push(`    - method ${m.isStatic ? 'static ' : ''}${m.isAsync ? 'async ' : ''}${m.name}(${m.parameters.join(', ')})${highlight}`);
+                }
+            }
+        }
+        // Check interfaces
+        for (const intf of file.interfaces) {
+            if (intf.name.toLowerCase().includes(queryLower)) {
+                fileHasMatch = true;
+                fileLines.push(`  interface ${intf.name} <-- MATCH`);
+            }
+        }
+        // Check functions
+        for (const fn of file.functions) {
+            if (fn.name.toLowerCase().includes(queryLower)) {
+                fileHasMatch = true;
+                fileLines.push(`  function ${fn.isAsync ? 'async ' : ''}${fn.name}(${fn.parameters.join(', ')}) <-- MATCH`);
+            }
+        }
+        // Check filepath match
+        if (file.filePath.toLowerCase().includes(queryLower) && !fileHasMatch) {
+            fileHasMatch = true;
+            fileLines.push(`  [File matched by name]`);
+        }
+        if (fileHasMatch) {
+            matches.push(`File: ${file.filePath}`);
+            matches.push(...fileLines);
+            matches.push('');
+        }
+    }
+    if (matches.length === 0) {
+        return `No matches found in code index for query "${query}".`;
+    }
+    return matches.join('\n').trim();
+}

package/dist/tools/math-helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum = sum;
+function sum(a, b) {
+    return a + b;
+}

package/dist/tools/repo-map.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRepoMap = generateRepoMap;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+function generateRepoMap(workspaceRoot = process.cwd()) {
+    const mapLines = [];
+    function walk(currentDir) {
+        const files = fs.readdirSync(currentDir);
+        for (const file of files) {
+            const fullPath = path.join(currentDir, file);
+            // Skip ignorable folders
+            if (file === 'node_modules' || file === '.git' || file === 'dist' || file === '.gemini') {
+                continue;
+            }
+            const stats = fs.statSync(fullPath);
+            if (stats.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (stats.isFile()) {
+                const ext = path.extname(file).toLowerCase();
+                if (ext === '.ts' || ext === '.js') {
+                    const relativePath = path.relative(workspaceRoot, fullPath).replace(/\\/g, '/');
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const signatures = extractSignatures(relativePath, content);
+                    if (signatures.length > 0) {
+                        mapLines.push(`File: ${relativePath}`);
+                        signatures.forEach(sig => mapLines.push(`  - ${sig}`));
+                        mapLines.push('');
+                    }
+                }
+            }
+        }
+    }
+    walk(workspaceRoot);
+    return mapLines.join('\n').trim();
+}
+/**
+ * Extracts class, interface, function, and method signatures using the TypeScript Compiler AST API.
+ */
+function extractSignatures(filePath, content) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const signatures = [];
+    let currentClass = null;
+    function visit(node) {
+        if (ts.isClassDeclaration(node) && node.name) {
+            const className = node.name.text;
+            signatures.push(`class ${className}`);
+            const oldClass = currentClass;
+            currentClass = className;
+            ts.forEachChild(node, visit);
+            currentClass = oldClass;
+        }
+        else if (ts.isInterfaceDeclaration(node) && node.name) {
+            signatures.push(`interface ${node.name.text}`);
+        }
+        else if (ts.isFunctionDeclaration(node) && node.name) {
+            const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+            const params = node.parameters.map(p => p.name.getText(sourceFile)).join(', ');
+            signatures.push(`${isAsync}function ${node.name.text}(${params})`);
+        }
+        else if (ts.isVariableStatement(node)) {
+            // Check if it is an exported const arrow/expression function
+            const isExport = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+            if (isExport) {
+                for (const decl of node.declarationList.declarations) {
+                    if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+                        const func = decl.initializer;
+                        const isAsync = func.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+                        const params = func.parameters.map(p => p.name.getText(sourceFile)).join(', ');
+                        signatures.push(`${isAsync}const ${decl.name.getText(sourceFile)} = (${params}) =>`);
+                    }
+                }
+            }
+        }
+        else if (currentClass && ts.isMethodDeclaration(node) && node.name) {
+            const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+            const isStatic = node.modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword) ? 'static ' : '';
+            const params = node.parameters.map(p => p.name.getText(sourceFile)).join(', ');
+            signatures.push(`method ${isStatic}${isAsync}${node.name.getText(sourceFile)}(${params})`);
+        }
+        else {
+            ts.forEachChild(node, visit);
+        }
+    }
+    ts.forEachChild(sourceFile, visit);
+    return signatures;
+}