ai-first-cli 1.3.5 → 1.3.8

package/src/core/content/contentProcessor.ts

@@ -0,0 +1,292 @@
+import { ContentProcessorOptions, ProcessedContent, DetailLevel, InclusionLevel } from './types.js';
+
+export function processContent(
+  content: string,
+  options: ContentProcessorOptions = {}
+): ProcessedContent {
+  const {
+    inclusionLevel = 'full',
+    detailLevel = 'full',
+    language = detectLanguage(content),
+    preserveComments = true,
+    preserveImports = true
+  } = options;
+
+  const originalLength = content.length;
+  let processedContent = content;
+
+  if (inclusionLevel === 'directory') {
+    return {
+      originalLength,
+      processedLength: 0,
+      compressionRatio: 100,
+      content: '',
+      tokens: 0
+    };
+  }
+
+  if (inclusionLevel === 'exclude') {
+    return {
+      originalLength,
+      processedLength: 0,
+      compressionRatio: 100,
+      content: '',
+      tokens: 0
+    };
+  }
+
+  if (inclusionLevel === 'compress' || detailLevel !== 'full') {
+    processedContent = compressContent(content, detailLevel, language, preserveComments, preserveImports);
+  }
+
+  const processedLength = processedContent.length;
+  const compressionRatio = originalLength > 0 
+    ? ((originalLength - processedLength) / originalLength) * 100 
+    : 0;
+  const tokens = estimateTokens(processedContent);
+
+  return {
+    originalLength,
+    processedLength,
+    compressionRatio,
+    content: processedContent,
+    tokens
+  };
+}
+
+function compressContent(
+  content: string,
+  detailLevel: DetailLevel,
+  language: string,
+  preserveComments: boolean,
+  preserveImports: boolean
+): string {
+  const lines = content.split('\n');
+  const result: string[] = [];
+  let inFunction = false;
+  let braceCount = 0;
+  let functionSignature: string | null = null;
+  let inComment = false;
+  let commentBlock: string[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith('/*')) {
+      inComment = true;
+    }
+
+    if (inComment) {
+      if (preserveComments && detailLevel !== 'skeleton') {
+        commentBlock.push(line);
+      }
+      if (trimmed.includes('*/')) {
+        inComment = false;
+        if (commentBlock.length > 0) {
+          result.push(...commentBlock);
+          commentBlock = [];
+        }
+      }
+      continue;
+    }
+
+    if (trimmed.startsWith('//') || trimmed.startsWith('#')) {
+      if (preserveComments && detailLevel !== 'skeleton') {
+        result.push(line);
+      }
+      continue;
+    }
+
+    if (preserveImports && isImportLine(trimmed, language)) {
+      result.push(line);
+      continue;
+    }
+
+    if (isExportLine(trimmed, language)) {
+      if (detailLevel === 'skeleton') {
+        const simplified = simplifyExport(line, language);
+        if (simplified) result.push(simplified);
+        continue;
+      }
+    }
+
+    if (isFunctionSignature(line, language)) {
+      if (inFunction) {
+        braceCount = 0;
+      }
+      inFunction = true;
+      functionSignature = line;
+      braceCount += countBraces(line);
+
+      if (detailLevel === 'signatures' || detailLevel === 'skeleton') {
+        const signature = extractSignature(line, language);
+        if (signature) result.push(signature);
+      }
+      continue;
+    }
+
+    if (inFunction) {
+      braceCount += countBraces(line);
+      if (braceCount <= 0) {
+        inFunction = false;
+        functionSignature = null;
+      }
+
+      if (detailLevel === 'full') {
+        result.push(line);
+      }
+      continue;
+    }
+
+    if (detailLevel === 'full') {
+      result.push(line);
+    }
+  }
+
+  return result.join('\n');
+}
+
+function isImportLine(line: string, language: string): boolean {
+  const importPatterns = [
+    /^import\s+/,
+    /^from\s+\w+\s+import/,
+    /^require\s*\(/,
+    /^using\s+/,
+    /^#include/,
+    /^#import/,
+    /^const\s+\w+\s+=\s+require\s*\(/,
+  ];
+  return importPatterns.some(pattern => pattern.test(line));
+}
+
+function isExportLine(line: string, language: string): boolean {
+  const exportPatterns = [
+    /^export\s+/,
+    /^module\.exports\s*=/,
+    /^exports\./,
+    /^public\s+/,
+  ];
+  return exportPatterns.some(pattern => pattern.test(line));
+}
+
+function simplifyExport(line: string, language: string): string | null {
+  const simplified = line.replace(/\{[\s\S]*\}/, '{ ... }');
+  return simplified;
+}
+
+function isFunctionSignature(line: string, language: string): boolean {
+  const patterns = [
+    /^(export\s+)?(async\s+)?function\s+\w+\s*\(/,
+    /^(export\s+)?(async\s+)?function\s*\(/,
+    /^(export\s+)?const\s+\w+\s*=\s*(async\s*)?\(/,
+    /^(export\s+)?(async\s+)?\w+\s*\([^)]*\)\s*{/,
+    /^(export\s+)?(async\s+)?\w+\s*\([^)]*\)\s*:\s*\w+\s*{/,
+    /^(export\s+)?class\s+\w+/,
+    /^(export\s+)?interface\s+\w+/,
+    /^(export\s+)?type\s+\w+\s*=/,
+    /^(public|private|protected)\s+(async\s+)?\w+\s*\(/,
+    /^\s*(async\s+)?def\s+\w+\s*\(/,
+    /^func\s+\w+\s*\(/,
+  ];
+  return patterns.some(pattern => pattern.test(line));
+}
+
+function extractSignature(line: string, language: string): string | null {
+  const signatureMatch = line.match(/^(.*\{)/);
+  if (signatureMatch) {
+    return signatureMatch[1] + ' ... }';
+  }
+
+  const arrowMatch = line.match(/^(.*=>).*$/);
+  if (arrowMatch) {
+    return arrowMatch[1] + ' ...;';
+  }
+
+  const classMatch = line.match(/^(export\s+)?class\s+\w+([^{]*)(\{)?/);
+  if (classMatch) {
+    return classMatch[1] || '' + 'class ' + line.match(/class\s+(\w+)/)?.[1] + ' { ... }';
+  }
+
+  const interfaceMatch = line.match(/^(export\s+)?interface\s+\w+/);
+  if (interfaceMatch) {
+    return line + ' { ... }';
+  }
+
+  return line + ';';
+}
+
+function countBraces(line: string): number {
+  let count = 0;
+  for (const char of line) {
+    if (char === '{') count++;
+    if (char === '}') count--;
+  }
+  return count;
+}
+
+function detectLanguage(content: string): string {
+  if (content.includes('interface ') || content.includes(': string') || content.includes(': number')) {
+    return 'typescript';
+  }
+  if (content.includes('def ') || content.includes('import ') && content.includes(':')) {
+    return 'python';
+  }
+  if (content.includes('func ') || content.includes('package main')) {
+    return 'go';
+  }
+  if (content.includes('fn ') || content.includes('let mut ')) {
+    return 'rust';
+  }
+  return 'javascript';
+}
+
+function estimateTokens(content: string): number {
+  return Math.ceil(content.length / 4);
+}
+
+export function classifyFile(
+  filePath: string,
+  includePatterns: string[],
+  compressPatterns: string[],
+  directoryPatterns: string[],
+  excludePatterns: string[]
+): InclusionLevel {
+  if (matchesPatterns(filePath, excludePatterns)) {
+    return 'exclude';
+  }
+
+  if (matchesPatterns(filePath, directoryPatterns)) {
+    return 'directory';
+  }
+
+  if (matchesPatterns(filePath, compressPatterns)) {
+    return 'compress';
+  }
+
+  if (includePatterns.length === 0 || matchesPatterns(filePath, includePatterns)) {
+    return 'full';
+  }
+
+  return 'exclude';
+}
+
+function matchesPatterns(filePath: string, patterns: string[]): boolean {
+  if (patterns.length === 0) return false;
+
+  return patterns.some(pattern => {
+    const regex = globToRegex(pattern);
+    return regex.test(filePath);
+  });
+}
+
+function globToRegex(pattern: string): RegExp {
+  let regex = pattern
+    .replace(/\*\*/g, '{{GLOBSTAR}}')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '.')
+    .replace(/\./g, '\\.')
+    .replace('{{GLOBSTAR}}', '.*');
+
+  return new RegExp(`^${regex}$`);
+}

package/src/core/content/index.ts

@@ -0,0 +1,9 @@
+export { processContent, classifyFile } from './contentProcessor.js';
+export type {
+  InclusionLevel,
+  DetailLevel,
+  FileClassification,
+  ContentProcessorOptions,
+  ProcessedContent,
+  CompressionStats
+} from './types.js';

package/src/core/content/types.ts

@@ -0,0 +1,35 @@
+export type InclusionLevel = 'full' | 'compress' | 'directory' | 'exclude';
+export type DetailLevel = 'full' | 'signatures' | 'skeleton';
+
+export interface FileClassification {
+  path: string;
+  inclusionLevel: InclusionLevel;
+  detailLevel: DetailLevel;
+}
+
+export interface ContentProcessorOptions {
+  inclusionLevel?: InclusionLevel;
+  detailLevel?: DetailLevel;
+  language?: string;
+  preserveComments?: boolean;
+  preserveImports?: boolean;
+}
+
+export interface ProcessedContent {
+  originalLength: number;
+  processedLength: number;
+  compressionRatio: number;
+  content: string;
+  tokens: number;
+}
+
+export interface CompressionStats {
+  totalFiles: number;
+  fullFiles: number;
+  compressedFiles: number;
+  directoryOnlyFiles: number;
+  excludedFiles: number;
+  originalTokens: number;
+  processedTokens: number;
+  savingsPercentage: number;
+}

package/src/core/gitAnalyzer.ts

@@ -389,3 +389,133 @@ export function generateGitContext(rootDir: string, aiDir?: string): {
     activity
   };
 }
+
+export interface GitBlameLine {
+  line: number;
+  content: string;
+  author: string;
+  date: string;
+  hash: string;
+}
+
+export interface GitBlameResult {
+  filePath: string;
+  lines: GitBlameLine[];
+  authors: Map<string, number>;
+}
+
+export function getGitBlame(rootDir: string, filePath: string): GitBlameResult {
+  const fullPath = path.join(rootDir, filePath);
+  
+  if (!fs.existsSync(fullPath)) {
+    return {
+      filePath,
+      lines: [],
+      authors: new Map()
+    };
+  }
+
+  if (!detectGitRepository(rootDir)) {
+    const content = fs.readFileSync(fullPath, 'utf-8');
+    const lines = content.split('\n');
+    return {
+      filePath,
+      lines: lines.map((content, idx) => ({
+        line: idx + 1,
+        content,
+        author: 'unknown',
+        date: '',
+        hash: ''
+      })),
+      authors: new Map([['unknown', lines.length]])
+    };
+  }
+
+  const blameOutput = gitExec(rootDir, `git blame --line-porcelain "${filePath}"`);
+  
+  if (!blameOutput) {
+    return {
+      filePath,
+      lines: [],
+      authors: new Map()
+    };
+  }
+
+  const lines: GitBlameLine[] = [];
+  const authors = new Map<string, number>();
+  const lineData: { hash?: string; author?: string; date?: string; content?: string } = {};
+  let lineNumber = 0;
+
+  const blameLines = blameOutput.split('\n');
+  
+  for (const blameLine of blameLines) {
+    if (blameLine.startsWith('\t')) {
+      lineData.content = blameLine.slice(1);
+      lineNumber++;
+      
+      const author = lineData.author || 'unknown';
+      const date = lineData.date || '';
+      const hash = lineData.hash || '';
+      
+      lines.push({
+        line: lineNumber,
+        content: lineData.content,
+        author,
+        date,
+        hash
+      });
+      
+      authors.set(author, (authors.get(author) || 0) + 1);
+      
+      lineData.hash = undefined;
+      lineData.author = undefined;
+      lineData.date = undefined;
+      lineData.content = undefined;
+    } else if (blameLine.startsWith('author ')) {
+      lineData.author = blameLine.slice(7);
+    } else if (blameLine.startsWith('author-time ')) {
+      const timestamp = parseInt(blameLine.slice(12), 10);
+      lineData.date = new Date(timestamp * 1000).toISOString().split('T')[0];
+    } else if (!blameLine.startsWith(' ') && blameLine.length >= 40) {
+      lineData.hash = blameLine.split(' ')[0];
+    }
+  }
+
+  return {
+    filePath,
+    lines,
+    authors
+  };
+}
+
+export function formatGitBlame(
+  blameResult: GitBlameResult,
+  format: 'inline' | 'block' = 'inline'
+): string {
+  if (format === 'block') {
+    const sections: string[] = [];
+    let currentAuthor = '';
+    let currentSection: string[] = [];
+    
+    for (const line of blameResult.lines) {
+      if (line.author !== currentAuthor) {
+        if (currentSection.length > 0) {
+          sections.push(`// ${currentAuthor}\n${currentSection.join('\n')}`);
+        }
+        currentAuthor = line.author;
+        currentSection = [];
+      }
+      currentSection.push(line.content);
+    }
+    
+    if (currentSection.length > 0) {
+      sections.push(`// ${currentAuthor}\n${currentSection.join('\n')}`);
+    }
+    
+    return sections.join('\n\n');
+  }
+  
+  return blameResult.lines
+    .map(line => `[${line.author} ${line.date}] ${line.content}`)
+    .join('\n');
+}

package/src/core/multiRepo/index.ts

@@ -0,0 +1,2 @@
+export { scanMultiRepo, generateMultiRepoReport } from './multiRepoScanner.js';
+export type { Repository, MultiRepoContext, MultiRepoOptions } from './multiRepoScanner.js';

package/src/core/multiRepo/multiRepoScanner.ts

@@ -0,0 +1,177 @@
+import path from 'path';
+import fs from 'fs';
+import { scanRepo, FileInfo } from '../repoScanner.js';
+
+export interface Repository {
+  name: string;
+  path: string;
+  files: FileInfo[];
+}
+
+export interface MultiRepoContext {
+  repositories: Repository[];
+  totalFiles: number;
+  crossRepoDependencies: Map<string, string[]>;
+}
+
+export interface MultiRepoOptions {
+  repositories: string[];
+  includeSubmodules?: boolean;
+}
+
+export function scanMultiRepo(options: MultiRepoOptions): MultiRepoContext {
+  const repositories: Repository[] = [];
+  const crossRepoDependencies = new Map<string, string[]>();
+  let totalFiles = 0;
+
+  for (const repoPath of options.repositories) {
+    const resolvedPath = path.resolve(repoPath);
+    
+    if (!fs.existsSync(resolvedPath)) {
+      console.warn(`Repository path does not exist: ${resolvedPath}`);
+      continue;
+    }
+
+    const repoName = path.basename(resolvedPath);
+    const scanResult = scanRepo(resolvedPath);
+    
+    repositories.push({
+      name: repoName,
+      path: resolvedPath,
+      files: scanResult.files
+    });
+    
+    totalFiles += scanResult.totalFiles;
+  }
+
+  if (options.includeSubmodules) {
+    for (const repo of repositories) {
+      const submodules = detectSubmodules(repo.path);
+      for (const submodule of submodules) {
+        const submoduleName = path.basename(submodule);
+        const scanResult = scanRepo(submodule);
+        
+        repositories.push({
+          name: `${repo.name}/${submoduleName}`,
+          path: submodule,
+          files: scanResult.files
+        });
+        
+        totalFiles += scanResult.totalFiles;
+      }
+    }
+  }
+
+  detectCrossRepoDependencies(repositories, crossRepoDependencies);
+
+  return {
+    repositories,
+    totalFiles,
+    crossRepoDependencies
+  };
+}
+
+function detectSubmodules(repoPath: string): string[] {
+  const submodules: string[] = [];
+  const gitmodulesPath = path.join(repoPath, '.gitmodules');
+  
+  if (!fs.existsSync(gitmodulesPath)) {
+    return submodules;
+  }
+
+  try {
+    const content = fs.readFileSync(gitmodulesPath, 'utf-8');
+    const matches = content.match(/path\s*=\s*(.+)/g);
+    
+    if (matches) {
+      for (const match of matches) {
+        const submodulePath = match.split('=')[1].trim();
+        const fullPath = path.join(repoPath, submodulePath);
+        if (fs.existsSync(fullPath)) {
+          submodules.push(fullPath);
+        }
+      }
+    }
+  } catch {
+    // Ignore errors reading .gitmodules
+  }
+
+  return submodules;
+}
+
+function detectCrossRepoDependencies(
+  repositories: Repository[],
+  dependencies: Map<string, string[]>
+): void {
+  for (const repo of repositories) {
+    const deps: string[] = [];
+    
+    for (const otherRepo of repositories) {
+      if (repo.name === otherRepo.name) continue;
+      
+      const hasDependency = checkDependency(repo, otherRepo);
+      if (hasDependency) {
+        deps.push(otherRepo.name);
+      }
+    }
+    
+    if (deps.length > 0) {
+      dependencies.set(repo.name, deps);
+    }
+  }
+}
+
+function checkDependency(repoA: Repository, repoB: Repository): boolean {
+  const packageJsonA = path.join(repoA.path, 'package.json');
+  
+  if (fs.existsSync(packageJsonA)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonA, 'utf-8'));
+      const deps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+        ...pkg.peerDependencies
+      };
+      
+      for (const dep of Object.keys(deps)) {
+        if (dep.includes(repoB.name.toLowerCase())) {
+          return true;
+        }
+      }
+    } catch {
+      // Ignore errors reading package.json
+    }
+  }
+  
+  return false;
+}
+
+export function generateMultiRepoReport(context: MultiRepoContext): string {
+  const lines: string[] = [];
+  
+  lines.push('# Multi-Repository Context\n');
+  lines.push(`## Summary`);
+  lines.push(`- **Total Repositories:** ${context.repositories.length}`);
+  lines.push(`- **Total Files:** ${context.totalFiles}\n`);
+  
+  lines.push(`## Repositories`);
+  for (const repo of context.repositories) {
+    lines.push(`\n### ${repo.name}`);
+    lines.push(`- **Path:** ${repo.path}`);
+    lines.push(`- **Files:** ${repo.files.length}`);
+    
+    const deps = context.crossRepoDependencies.get(repo.name);
+    if (deps && deps.length > 0) {
+      lines.push(`- **Dependencies:** ${deps.join(', ')}`);
+    }
+  }
+  
+  if (context.crossRepoDependencies.size > 0) {
+    lines.push(`\n## Cross-Repository Dependencies`);
+    for (const [repo, deps] of context.crossRepoDependencies) {
+      lines.push(`- **${repo}** depends on: ${deps.join(', ')}`);
+    }
+  }
+  
+  return lines.join('\n');
+}

package/src/core/rag/index.ts

@@ -0,0 +1,2 @@
+export { VectorIndex, createVectorIndex, semanticSearch } from './vectorIndex.js';
+export type { VectorDocument, SearchResult } from './vectorIndex.js';