closed-loop-cli 1.0.0

package/src/tools/indexer.ts

@@ -0,0 +1,325 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+export interface IndexedMethod {
+  name: string;
+  isStatic: boolean;
+  isAsync: boolean;
+  parameters: string[];
+}
+
+export interface IndexedClass {
+  name: string;
+  methods: IndexedMethod[];
+}
+
+export interface IndexedInterface {
+  name: string;
+}
+
+export interface IndexedFunction {
+  name: string;
+  isAsync: boolean;
+  parameters: string[];
+}
+
+export interface IndexedFile {
+  filePath: string;
+  classes: IndexedClass[];
+  interfaces: IndexedInterface[];
+  functions: IndexedFunction[];
+  imports: string[];
+  exports: string[];
+}
+
+/**
+ * Resolves relative module import paths to standardized workspace-relative paths.
+ */
+function resolveImportPath(fromFile: string, importPath: string, workspaceRoot: string = process.cwd()): string | null {
+  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.
+ */
+export function generateCodeIndex(workspaceRoot: string = process.cwd()): IndexedFile[] {
+  const index: IndexedFile[] = [];
+
+  function walk(currentDir: string) {
+    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: string, content: string): IndexedFile {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.Latest,
+    true
+  );
+
+  const fileIndex: IndexedFile = {
+    filePath,
+    classes: [],
+    interfaces: [],
+    functions: [],
+    imports: [],
+    exports: []
+  };
+
+  let currentClass: IndexedClass | null = null;
+
+  function visit(node: ts.Node) {
+    const isExport = ((node as any).modifiers?.some((m: any) => 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: IndexedClass = {
+        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 as any).modifiers?.some((m: any) => 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 as any).modifiers?.some((m: any) => 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 as any).modifiers?.some((m: any) => m.kind === ts.SyntaxKind.AsyncKeyword)) || false;
+      const isStatic = ((node as any).modifiers?.some((m: any) => 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.
+ */
+export function getDependents(targetFile: string, workspaceRoot: string = process.cwd()): string[] {
+  const indexPath = path.join(workspaceRoot, 'code-index.json');
+  if (!fs.existsSync(indexPath)) {
+    return [];
+  }
+
+  let index: IndexedFile[] = [];
+  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: string[] = [];
+  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.
+ */
+export function queryCodeIndex(query: string, workspaceRoot: string = process.cwd()): string {
+  const indexPath = path.join(workspaceRoot, 'code-index.json');
+  if (!fs.existsSync(indexPath)) {
+    generateCodeIndex(workspaceRoot);
+  }
+
+  let index: IndexedFile[] = [];
+  try {
+    index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+  } catch (e) {
+    return `Error reading code-index.json: ${(e as Error).message}`;
+  }
+
+  const queryLower = query.toLowerCase();
+  const matches: string[] = [];
+
+  for (const file of index) {
+    let fileHasMatch = false;
+    const fileLines: string[] = [];
+
+    // 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/src/tools/repo-map.ts

@@ -0,0 +1,96 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+export function generateRepoMap(workspaceRoot: string = process.cwd()): string {
+  const mapLines: string[] = [];
+
+  function walk(currentDir: string) {
+    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: string, content: string): string[] {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  
+  const signatures: string[] = [];
+  let currentClass: string | null = null;
+
+  function visit(node: ts.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;
+}

package/src/tools/search-tools.ts

@@ -0,0 +1,258 @@
+import * as https from 'https';
+
+export interface SearchResult {
+  title: string;
+  link: string;
+  snippet: string;
+}
+
+/**
+ * Strips HTML tags from a string.
+ */
+function stripHtml(text: string): string {
+  return text.replace(/<[^>]*>/g, '').trim();
+}
+
+/**
+ * Decodes common HTML entities.
+ */
+function decodeEntities(text: string): string {
+  return text
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#x27;/g, "'")
+    .replace(/&#x2F;/g, '/')
+    .replace(/&#39;/g, "'");
+}
+
+/**
+ * Formats results list into a readable string.
+ */
+function formatResults(query: string, results: SearchResult[], source: string): string {
+  let formatted = `Web search results (via ${source}) for: "${query}"\n\n`;
+  results.forEach((res, index) => {
+    formatted += `${index + 1}. ${res.title}\n`;
+    formatted += `   URL: ${res.link}\n`;
+    formatted += `   Snippet: ${res.snippet}\n\n`;
+  });
+  return formatted.trim();
+}
+
+/**
+ * Searches the web using DuckDuckGo Lite POST interface, falling back to DDG JSON and Wikipedia APIs on failure.
+ */
+export async function searchWeb(query: string): Promise<string> {
+  // 1. Try DuckDuckGo Lite POST
+  try {
+    const results = await fetchDuckDuckGoLite(query);
+    if (results.length > 0) {
+      return formatResults(query, results, 'DuckDuckGo Lite');
+    }
+  } catch (err) {
+    // Ignore and try next fallback
+  }
+
+  // 2. Try DuckDuckGo Instant Answer JSON API
+  try {
+    const results = await fetchDuckDuckGoApi(query);
+    if (results.length > 0) {
+      return formatResults(query, results, 'DuckDuckGo API');
+    }
+  } catch (err) {
+    // Ignore and try next fallback
+  }
+
+  // 3. Try Wikipedia Search API
+  try {
+    const results = await fetchWikipedia(query);
+    if (results.length > 0) {
+      return formatResults(query, results, 'Wikipedia');
+    }
+  } catch (err) {
+    // Ignore
+  }
+
+  return `No search results found for: "${query}". (Web search services are currently rate-limited or unavailable).`;
+}
+
+/**
+ * DuckDuckGo Lite Scraper
+ */
+function fetchDuckDuckGoLite(query: string): Promise<SearchResult[]> {
+  return new Promise((resolve, reject) => {
+    const encodedQuery = encodeURIComponent(query);
+    const postData = `q=${encodedQuery}`;
+    
+    const options = {
+      hostname: 'lite.duckduckgo.com',
+      port: 443,
+      path: '/lite/',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': Buffer.byteLength(postData),
+        'User-Agent': 'ClosedLoopCodingAgent/1.0 (contact: akara@example.com)',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5'
+      },
+      timeout: 6000
+    };
+
+    const req = https.request(options, (res) => {
+      if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+        return reject(new Error(`Status ${res.statusCode}`));
+      }
+
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const results = parseDuckDuckGoLiteHTML(data);
+          resolve(results);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(err));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Timeout'));
+    });
+    req.write(postData);
+    req.end();
+  });
+}
+
+function parseDuckDuckGoLiteHTML(html: string): SearchResult[] {
+  const results: SearchResult[] = [];
+  const resultRegex = /<a[^>]+href="([^"]+)"[^>]+class='result-link'[^>]*>([\s\S]*?)<\/a>[\s\S]*?class='result-snippet'[^>]*>([\s\S]*?)<\/td>/gi;
+  
+  let match;
+  while ((match = resultRegex.exec(html)) !== null && results.length < 8) {
+    const rawLink = match[1];
+    const title = decodeEntities(stripHtml(match[2]));
+    const snippet = decodeEntities(stripHtml(match[3]));
+    if (!title || !snippet) continue;
+    
+    let link = rawLink;
+    if (link.startsWith('//')) {
+      link = 'https:' + link;
+    }
+    if (link.includes('uddg=')) {
+      const uddgMatch = link.match(/uddg=([^&]+)/);
+      if (uddgMatch) {
+        link = decodeURIComponent(uddgMatch[1]);
+      }
+    }
+    results.push({ title, link, snippet });
+  }
+  return results;
+}
+
+/**
+ * DuckDuckGo Instant Answer API
+ */
+function fetchDuckDuckGoApi(query: string): Promise<SearchResult[]> {
+  return new Promise((resolve, reject) => {
+    const encodedQuery = encodeURIComponent(query);
+    const url = `https://api.duckduckgo.com/?q=${encodedQuery}&format=json&no_html=1&skip_disambig=1`;
+    
+    const options = {
+      headers: {
+        'User-Agent': 'ClosedLoopCodingAgent/1.0 (contact: akara@example.com)'
+      },
+      timeout: 5000
+    };
+
+    https.get(url, options, (res) => {
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Status ${res.statusCode}`));
+      }
+
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          const results: SearchResult[] = [];
+          
+          if (json.AbstractText && json.AbstractURL) {
+            results.push({
+              title: json.Heading || query,
+              link: json.AbstractURL,
+              snippet: json.AbstractText
+            });
+          }
+          
+          if (json.RelatedTopics && Array.isArray(json.RelatedTopics)) {
+            for (const topic of json.RelatedTopics) {
+              if (results.length >= 5) break;
+              if (topic.Text && topic.FirstURL) {
+                results.push({
+                  title: topic.Text.split(' - ')[0] || 'Topic Details',
+                  link: topic.FirstURL,
+                  snippet: topic.Text
+                });
+              }
+            }
+          }
+          
+          resolve(results);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }).on('error', (err) => reject(err));
+  });
+}
+
+/**
+ * Wikipedia Search API
+ */
+function fetchWikipedia(query: string): Promise<SearchResult[]> {
+  return new Promise((resolve, reject) => {
+    const encodedQuery = encodeURIComponent(query);
+    const url = `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodedQuery}&format=json&origin=*`;
+    
+    const options = {
+      headers: {
+        'User-Agent': 'ClosedLoopCodingAgent/1.0 (contact: akara@example.com)'
+      },
+      timeout: 5000
+    };
+
+    https.get(url, options, (res) => {
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Status ${res.statusCode}`));
+      }
+
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          const results: SearchResult[] = [];
+          if (json.query && Array.isArray(json.query.search)) {
+            for (const item of json.query.search) {
+              if (results.length >= 8) break;
+              const link = `https://en.wikipedia.org/wiki/${encodeURIComponent(item.title.replace(/ /g, '_'))}`;
+              const snippet = stripHtml(item.snippet);
+              results.push({
+                title: item.title,
+                link,
+                snippet
+              });
+            }
+          }
+          resolve(results);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }).on('error', (err) => reject(err));
+  });
+}