ai-first-cli 1.3.6 → 1.3.8

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';

package/src/core/rag/vectorIndex.ts

@@ -0,0 +1,105 @@
+import fs from 'fs';
+import path from 'path';
+
+export interface VectorDocument {
+  id: string;
+  content: string;
+  embedding: number[];
+  metadata: {
+    filePath: string;
+    language?: string;
+    type?: 'function' | 'class' | 'interface' | 'variable';
+  };
+}
+
+export interface SearchResult {
+  document: VectorDocument;
+  score: number;
+}
+
+export class VectorIndex {
+  private documents: Map<string, VectorDocument> = new Map();
+  private indexPath: string;
+
+  constructor(indexPath: string) {
+    this.indexPath = indexPath;
+    this.load();
+  }
+
+  private load(): void {
+    if (fs.existsSync(this.indexPath)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(this.indexPath, 'utf-8'));
+        this.documents = new Map(Object.entries(data));
+      } catch {
+        this.documents = new Map();
+      }
+    }
+  }
+
+  save(): void {
+    const data = Object.fromEntries(this.documents);
+    fs.writeFileSync(this.indexPath, JSON.stringify(data, null, 2));
+  }
+
+  addDocument(doc: VectorDocument): void {
+    this.documents.set(doc.id, doc);
+  }
+
+  search(query: string, topK: number = 5): SearchResult[] {
+    const queryEmbedding = this.simpleEmbedding(query);
+    const results: SearchResult[] = [];
+
+    for (const doc of this.documents.values()) {
+      const score = this.cosineSimilarity(queryEmbedding, doc.embedding);
+      results.push({ document: doc, score });
+    }
+
+    return results
+      .sort((a, b) => b.score - a.score)
+      .slice(0, topK);
+  }
+
+  private simpleEmbedding(text: string): number[] {
+    const words = text.toLowerCase().split(/\s+/);
+    const embedding: number[] = new Array(100).fill(0);
+    
+    for (let i = 0; i < words.length && i < 100; i++) {
+      let hash = 0;
+      for (const char of words[i]) {
+        hash = ((hash << 5) - hash) + char.charCodeAt(0);
+        hash = hash & hash;
+      }
+      embedding[i] = Math.sin(hash) * 0.5 + 0.5;
+    }
+    
+    return embedding;
+  }
+
+  private cosineSimilarity(a: number[], b: number[]): number {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+
+    if (normA === 0 || normB === 0) return 0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+}
+
+export function createVectorIndex(indexPath: string): VectorIndex {
+  return new VectorIndex(indexPath);
+}
+
+export function semanticSearch(
+  index: VectorIndex,
+  query: string,
+  topK: number = 5
+): SearchResult[] {
+  return index.search(query, topK);
+}

package/src/mcp/index.ts

@@ -0,0 +1 @@
+export { startMCPServer, startMCP } from './server.js';

package/src/mcp/server.ts

@@ -0,0 +1,179 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { runAIFirst } from '../commands/ai-first.js';
+import { generateIndex } from '../core/indexer.js';
+import { buildKnowledgeGraph } from '../core/knowledgeGraphBuilder.js';
+import { analyzeArchitecture } from '../analyzers/architecture.js';
+
+interface MCPServerOptions {
+  rootDir?: string;
+  aiDir?: string;
+}
+
+export function startMCPServer(options: MCPServerOptions = {}): void {
+  const rootDir = options.rootDir || process.cwd();
+  const aiDir = options.aiDir || `${rootDir}/ai-context`;
+
+  const server = new Server(
+    {
+      name: 'ai-first-cli',
+      version: '1.4.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: 'generate_context',
+          description: 'Generate AI context for the repository or a specific module',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              module: {
+                type: 'string',
+                description: 'Optional module path to generate context for (e.g., "src/auth")',
+              },
+              preset: {
+                type: 'string',
+                enum: ['full', 'quick', 'api', 'docs'],
+                description: 'Preset to use for context generation',
+              },
+            },
+          },
+        },
+        {
+          name: 'query_symbols',
+          description: 'Query symbols (functions, classes, interfaces) in the indexed repository',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              query: {
+                type: 'string',
+                description: 'Search query for symbols',
+              },
+              type: {
+                type: 'string',
+                enum: ['function', 'class', 'interface', 'variable', 'all'],
+                description: 'Type of symbol to search for',
+              },
+            },
+            required: ['query'],
+          },
+        },
+        {
+          name: 'get_architecture',
+          description: 'Get the architecture analysis of the project',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              format: {
+                type: 'string',
+                enum: ['summary', 'detailed'],
+                description: 'Level of detail for the architecture report',
+              },
+            },
+          },
+        },
+      ],
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+      switch (name) {
+        case 'generate_context': {
+          const result = await runAIFirst({
+            rootDir,
+            outputDir: aiDir,
+          });
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  success: result.success,
+                  filesCreated: result.filesCreated,
+                  message: result.success 
+                    ? `Generated context in ${aiDir}` 
+                    : `Error: ${result.error}`,
+                }, null, 2),
+              },
+            ],
+          };
+        }
+
+        case 'query_symbols': {
+          const query = args?.query as string;
+          const symbolType = (args?.type as string) || 'all';
+          
+          const index = generateIndex(rootDir, aiDir);
+          
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  query,
+                  type: symbolType,
+                  results: [],
+                  message: `Symbol query executed for "${query}"`,
+                }, null, 2),
+              },
+            ],
+          };
+        }
+
+        case 'get_architecture': {
+          const format = (args?.format as string) || 'summary';
+          
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  format,
+                  rootDir,
+                  message: 'Architecture analysis available',
+                }, null, 2),
+              },
+            ],
+          };
+        }
+
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              error: error instanceof Error ? error.message : String(error),
+            }, null, 2),
+          },
+        ],
+        isError: true,
+      };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  server.connect(transport);
+  
+  console.error('AI-First MCP Server running on stdio');
+}
+
+export { startMCPServer as startMCP };