ai-first-cli 1.1.0 → 1.1.2

package/src/commands/ai-first.ts

@@ -18,8 +18,17 @@ import { generateModuleGraph } from "../core/moduleGraph.js";
 import { loadIndexState, computeFileHash, getFilesToIndex, getChangedFilesGit } from "../core/indexState.js";
 import { chunkFiles } from "../core/chunker.js";
 import { generateEmbeddings, saveEmbeddings } from "../core/embeddings.js";
+import { generateContextModules, createCCP, listCCPs, getCCP } from "../core/ccp.js";
+import { generateSemanticContexts } from "../core/semanticContexts.js";
 import { doctorMain } from "./doctor.js";
 import { exploreMain } from "./explore.js";
+import { listAdapters } from "../core/adapters/index.js";
+import { detectGitRepository, generateGitContext, analyzeGitActivity, getRecentFiles } from "../core/gitAnalyzer.js";
+import { buildKnowledgeGraph, loadKnowledgeGraph } from "../core/knowledgeGraphBuilder.js";
+import { runIncrementalUpdate, detectChangedFiles } from "../core/incrementalAnalyzer.js";
+import { generateAllSchema } from "../core/schema.js";
+import ora from "ora";
+import process from "process";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -147,6 +156,26 @@ export async function runAIFirst(options: AIFirstOptions = {}): Promise<AIFirstR
     filesCreated.push(aiContextPath);
     console.log("   ✅ Created ai_context.md");
 
+    // Generate semantic contexts (features and flows)
+    try {
+      const { features, flows } = generateSemanticContexts(outputDir);
+      console.log(`   ✅ Created ${features.length} features, ${flows.length} flows`);
+    } catch (e: any) {
+      console.log("   ⚠️  Semantic contexts: " + (e.message || e));
+    }
+
+    // Generate AI Repository Schema (schema.json, project.json, tools.json)
+    try {
+      generateAllSchema(rootDir, outputDir);
+      console.log("   ✅ Created schema.json, project.json, tools.json");
+    } catch (e: any) {
+      console.log("   ⚠️  Schema generation: " + (e.message || e));
+    }
+
+    console.log("\n✨ Done! Created the following files:");
+
+    console.log("\n✨ Done! Created the following files:");
+
     console.log("\n✨ Done! Created the following files:");
     for (const file of filesCreated) {
       console.log(`   - ${path.relative(rootDir, file)}`);
@@ -1016,6 +1045,9 @@ Commands:
   doctor               Check repository health and AI readiness
   explore <module>     Explore module dependencies
   map                  Generate repository map (files, modules, graph)
+  adapters              List available adapters
+  explore <module>     Explore module dependencies
+  map                  Generate repository map (files, modules, graph)
 
 Options:
   -r, --root <dir>      Root directory to scan (default: current directory)
@@ -1080,12 +1112,321 @@ Options:
     await generateSymbolGraph(rootDir, aiDir);
     console.log("   ✅ symbol-graph.json");
     
-    console.log("\n✅ Repository map generated!");
+    // Generate semantic contexts (features and flows)
+    const { features, flows } = generateSemanticContexts(aiDir);
+    console.log(`   ✅ Created ${features.length} features, ${flows.length} flows`);
+    
     process.exit(0);
   } else if (command === 'doctor') {
     doctorMain(args.slice(1));
   } else if (command === 'explore') {
     exploreMain(args.slice(1));
+  } else if (command === 'adapters') {
+    // Adapters command - list available adapters
+    args.shift();
+    
+    const showJson = args.includes('--json');
+    
+    if (args.includes('--help') || args.includes('-h')) {
+      console.log(`
+adapters - List available adapters
+
+Usage: ai-first adapters [options]
+
+Options:
+  --json        Output as JSON
+  -h, --help    Show help message
+
+Examples:
+  ai-first adapters
+  ai-first adapters --json
+`);
+      process.exit(0);
+    }
+    
+    const adapters = listAdapters();
+    
+    if (showJson) {
+      console.log(JSON.stringify(adapters, null, 2));
+    } else {
+      console.log("\n📦 Available adapters:\n");
+      console.log("Name                | Display Name");
+      console.log("--------------------|-------------------");
+      for (const adapter of adapters) {
+        console.log(`${adapter.name.padEnd(18)}| ${adapter.displayName}`);
+      }
+      console.log(`\nTotal: ${adapters.length} adapters`);
+    }
+    process.exit(0);
+  } else if (command === 'git') {
+    // Git intelligence command
+    args.shift();
+    
+    let rootDir = process.cwd();
+    let aiDir = path.join(rootDir, "ai");
+    let limit = 50;
+    let showActivity = false;
+    let showJson = false;
+    
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      switch (arg) {
+        case "--root":
+        case "-r":
+          rootDir = args[++i];
+          aiDir = path.join(rootDir, "ai");
+          break;
+        case "--limit":
+        case "-n":
+          limit = parseInt(args[++i], 10) || 50;
+          break;
+        case "--activity":
+        case "-a":
+          showActivity = true;
+          break;
+        case "--json":
+          showJson = true;
+          break;
+        case "--help":
+        case "-h":
+          console.log(`
+git - Analyze recent git activity
+
+Usage: ai-first git [options]
+
+Options:
+  -r, --root <dir>     Root directory (default: current directory)
+  -n, --limit <n>      Number of commits to analyze (default: 50)
+  -a, --activity       Show commit activity details
+  --json               Output as JSON
+  -h, --help           Show help message
+
+Examples:
+  ai-first git
+  ai-first git --limit 100
+  ai-first git --activity
+`);
+          process.exit(0);
+      }
+    }
+    
+    if (!detectGitRepository(rootDir)) {
+      console.log("❌ Not a git repository");
+      process.exit(1);
+    }
+    
+    console.log(`\n📊 Analyzing git activity in: ${rootDir}\n`);
+    
+    const result = generateGitContext(rootDir, aiDir);
+    
+    if (showJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log("📁 Recent files:");
+      for (const file of result.recentFiles.slice(0, 10)) {
+        console.log(`   - ${file}`);
+      }
+      if (result.recentFiles.length > 10) {
+        console.log(`   ... and ${result.recentFiles.length - 10} more`);
+      }
+      
+      if (result.recentFeatures.length > 0) {
+        console.log("\n🎯 Recent features:");
+        console.log(`   ${result.recentFeatures.join(", ")}`);
+      }
+      
+      if (result.recentFlows.length > 0) {
+        console.log("\n🔄 Recent flows:");
+        console.log(`   ${result.recentFlows.join(", ")}`);
+      }
+      
+      if (showActivity && result.activity) {
+        console.log("\n📈 Commit activity:");
+        console.log(`   Total commits: ${result.activity.totalCommits}`);
+        console.log(`   Date range: ${result.activity.dateRange.start.slice(0, 10)} - ${result.activity.dateRange.end.slice(0, 10)}`);
+        
+        const topFiles = Object.entries(result.activity.files)
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 5);
+        if (topFiles.length > 0) {
+          console.log("\n   Most changed files:");
+          for (const [file, count] of topFiles) {
+            console.log(`   - ${file}: ${count} commits`);
+          }
+        }
+      }
+      
+      console.log("\n✅ Generated:");
+      console.log("   - ai/git/recent-files.json");
+      console.log("   - ai/git/recent-features.json");
+      console.log("   - ai/git/recent-flows.json");
+      if (result.activity) {
+        console.log("   - ai/git/commit-activity.json");
+      }
+    }
+    process.exit(0);
+  } else if (command === 'graph') {
+    // Knowledge Graph command
+    args.shift();
+    
+    let rootDir = process.cwd();
+    let aiDir = path.join(rootDir, "ai");
+    let showJson = false;
+    let showStats = false;
+    
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      switch (arg) {
+        case "--root":
+        case "-r":
+          rootDir = args[++i];
+          aiDir = path.join(rootDir, "ai");
+          break;
+        case "--json":
+          showJson = true;
+          break;
+        case "--stats":
+        case "-s":
+          showStats = true;
+          break;
+        case "--help":
+        case "-h":
+          console.log(`
+graph - Generate repository knowledge graph
+
+Usage: ai-first graph [options]
+
+Options:
+  -r, --root <dir>   Root directory (default: current directory)
+  -s, --stats        Show graph statistics
+  --json              Output as JSON
+  -h, --help         Show help message
+
+Examples:
+  ai-first graph
+  ai-first graph --stats
+`);
+          process.exit(0);
+      }
+    }
+    
+    if (!detectGitRepository(rootDir)) {
+      console.log("❌ Not a git repository");
+      process.exit(1);
+    }
+    
+    console.log(`\n🕸️  Building knowledge graph in: ${rootDir}\n`);
+    
+    const graph = buildKnowledgeGraph(rootDir, aiDir);
+    
+    if (showJson) {
+      console.log(JSON.stringify(graph, null, 2));
+    } else {
+      console.log("📊 Graph Statistics:");
+      console.log(`   Nodes: ${graph.nodes.length}`);
+      console.log(`   Edges: ${graph.edges.length}`);
+      console.log(`   Sources: ${graph.metadata.sources.join(", ") || "none"}`);
+      
+      const nodeTypes = graph.nodes.reduce((acc, n) => { acc[n.type] = (acc[n.type] || 0) + 1; return acc; }, {} as Record<string, number>);
+      const edgeTypes = graph.edges.reduce((acc, e) => { acc[e.type] = (acc[e.type] || 0) + 1; return acc; }, {} as Record<string, number>);
+      
+      console.log("\n📍 Node Types:");
+      for (const [type, count] of Object.entries(nodeTypes)) {
+        console.log(`   ${type}: ${count}`);
+      }
+      
+      console.log("\n🔗 Edge Types:");
+      for (const [type, count] of Object.entries(edgeTypes)) {
+        console.log(`   ${type}: ${count}`);
+      }
+      
+      console.log("\n✅ Generated:");
+      console.log("   - ai/graph/knowledge-graph.json");
+    }
+    process.exit(0);
+  } else if (command === 'update') {
+    // Incremental update command
+    args.shift();
+    
+    let rootDir = process.cwd();
+    let aiDir = path.join(rootDir, "ai");
+    let useGit = true;
+    let showJson = false;
+    
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      switch (arg) {
+        case "--root":
+        case "-r":
+          rootDir = args[++i];
+          aiDir = path.join(rootDir, "ai");
+          break;
+        case "--no-git":
+          useGit = false;
+          break;
+        case "--json":
+          showJson = true;
+          break;
+        case "--help":
+        case "-h":
+          console.log(`
+update - Incrementally update repository context
+
+Usage: ai-first update [options]
+
+Options:
+  -r, --root <dir>   Root directory (default: current directory)
+  --no-git            Use filesystem timestamps instead of git
+  --json             Output as JSON
+  -h, --help         Show help message
+
+Examples:
+  ai-first update
+  ai-first update --no-git
+`);
+          process.exit(0);
+      }
+    }
+    
+    if (!fs.existsSync(aiDir)) {
+      console.log("❌ AI context not found. Run 'ai-first init' first.");
+      process.exit(1);
+    }
+    
+    console.log(`\n🔄 Running incremental update in: ${rootDir}\n`);
+    
+    const result = runIncrementalUpdate(rootDir, aiDir);
+    
+    if (result.errors.length > 0) {
+      console.log("⚠️  Errors:");
+      for (const error of result.errors) {
+        console.log(`   - ${error}`);
+      }
+    }
+    
+    if (showJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`📁 Changed files: ${result.changedFiles.length}`);
+      if (result.changedFiles.length > 0) {
+        for (const file of result.changedFiles.slice(0, 5)) {
+          console.log(`   ${file.status}: ${file.path}`);
+        }
+        if (result.changedFiles.length > 5) {
+          console.log(`   ... and ${result.changedFiles.length - 5} more`);
+        }
+      }
+      
+      console.log(`\n🔧 Updated:`);
+      console.log(`   Symbols: ${result.updatedSymbols}`);
+      console.log(`   Dependencies: ${result.updatedDependencies}`);
+      console.log(`   Features: ${result.updatedFeatures.join(", ") || "none"}`);
+      console.log(`   Flows: ${result.updatedFlows.join(", ") || "none"}`);
+      console.log(`   Knowledge Graph: ${result.graphUpdated ? "✅" : "❌"}`);
+    }
+    
+    process.exit(0);
+    process.exit(0);
   } else {
     console.log(`Unknown command: ${command}`);
     console.log(`Use 'ai-first --help' for usage information`);

package/src/core/adapters/adapterRegistry.ts

@@ -0,0 +1,187 @@
+import fs from "fs";
+import path from "path";
+import { AnalysisAdapter, DEFAULT_ADAPTER } from "./baseAdapter.js";
+import { javascriptAdapter } from "./javascriptAdapter.js";
+import { pythonAdapter, djangoAdapter, flaskAdapter } from "./pythonAdapter.js";
+import { railsAdapter, rubyAdapter } from "./railsAdapter.js";
+import { salesforceAdapter, sfdxAdapter } from "./salesforceAdapter.js";
+import { dotnetAdapter, aspnetCoreAdapter, blazorAdapter } from "./dotnetAdapter.js";
+import { laravelAdapter, nestjsAdapter, springBootAdapter, phoenixAdapter, fastapiAdapter } from "./community/index.js";
+
+/**
+ * Registry of all available adapters
+ */
+export const ADAPTERS: AnalysisAdapter[] = [
+  // JavaScript/TypeScript
+  javascriptAdapter,
+  nestjsAdapter,
+  
+  // Ruby (must be before Python to detect Gemfile correctly)
+  railsAdapter,
+  rubyAdapter,
+  
+  // Python
+  djangoAdapter,
+  flaskAdapter,
+  pythonAdapter,
+  fastapiAdapter,
+  
+  // PHP
+  laravelAdapter,
+  
+  // Elixir
+  phoenixAdapter,
+  
+  // Java/Kotlin
+  springBootAdapter,
+  
+  // Salesforce
+  sfdxAdapter,
+  salesforceAdapter,
+  
+  // .NET
+  blazorAdapter,
+  aspnetCoreAdapter,
+  dotnetAdapter
+];
+
+/**
+ * Adapter detection result
+ */
+export interface AdapterDetectionResult {
+  adapter: AnalysisAdapter;
+  confidence: number;
+  matchedSignals: string[];
+}
+
+/**
+ * Detect the appropriate adapter for a project
+ * 
+ * @param rootDir - Project root directory
+ * @returns The best matching adapter
+ */
+export function detectAdapter(rootDir: string): AnalysisAdapter {
+  const results = detectAllAdapters(rootDir);
+  
+  if (results.length === 0) {
+    return DEFAULT_ADAPTER;
+  }
+  
+  // Return the adapter with highest confidence
+  return results[0].adapter;
+}
+
+/**
+ * Detect all matching adapters with confidence scores
+ * 
+ * @param rootDir - Project root directory
+ * @returns Array of matching adapters sorted by confidence
+ */
+export function detectAllAdapters(rootDir: string): AdapterDetectionResult[] {
+  const results: AdapterDetectionResult[] = [];
+  
+  for (const adapter of ADAPTERS) {
+    const matchedSignals: string[] = [];
+    let score = 0;
+    
+    for (const signal of adapter.detectionSignals) {
+      const matched = matchSignal(rootDir, signal);
+      if (matched) {
+        matchedSignals.push(signal.pattern);
+        score += getSignalWeight(signal);
+      }
+    }
+    
+    if (score > 0) {
+      results.push({
+        adapter,
+        confidence: score,
+        matchedSignals
+      });
+    }
+  }
+  
+  // Sort by confidence (highest first)
+  results.sort((a, b) => b.confidence - a.confidence);
+  
+  return results;
+}
+
+/**
+ * Match a detection signal against the project
+ */
+function matchSignal(rootDir: string, signal: { type: string; pattern: string; contentPattern?: string }): boolean {
+  switch (signal.type) {
+    case 'file':
+      return matchFileSignal(rootDir, signal.pattern);
+    
+    case 'directory':
+      return matchDirectorySignal(rootDir, signal.pattern);
+    
+    case 'content':
+      // Content signals require more complex implementation
+      // For now, we skip content-based detection
+      return false;
+    
+    default:
+      return false;
+  }
+}
+
+/**
+ * Match a file signal
+ */
+function matchFileSignal(rootDir: string, pattern: string): boolean {
+  // Simple glob support for *.csproj style patterns
+  if (pattern.startsWith('*')) {
+    const ext = pattern.slice(1);
+    if (!fs.existsSync(rootDir)) return false;
+    const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+    return entries.some(e => e.isFile() && e.name.endsWith(ext));
+  }
+  
+  return fs.existsSync(path.join(rootDir, pattern));
+}
+
+/**
+ * Match a directory signal
+ */
+function matchDirectorySignal(rootDir: string, pattern: string): boolean {
+  if (!fs.existsSync(rootDir)) return false;
+  
+  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+  return entries.some(e => e.isDirectory() && e.name === pattern);
+}
+
+/**
+ * Get weight for a signal type
+ */
+function getSignalWeight(signal: { type: string; pattern: string }): number {
+  // Higher weight for more specific signals
+  switch (signal.type) {
+    case 'content':
+      return 3;
+    case 'directory':
+      return 2;
+    case 'file':
+    default:
+      // Higher weight for more specific file patterns
+      if (signal.pattern.startsWith('*')) return 1;
+      if (signal.pattern.includes('.')) return 2;
+      return 1;
+  }
+}
+
+/**
+ * Get adapter by name
+ */
+export function getAdapter(name: string): AnalysisAdapter | undefined {
+  return ADAPTERS.find(a => a.name === name);
+}
+
+/**
+ * List all available adapters
+ */
+export function listAdapters(): { name: string; displayName: string }[] {
+  return ADAPTERS.map(a => ({ name: a.name, displayName: a.displayName }));
+}

package/src/core/adapters/baseAdapter.ts

@@ -0,0 +1,82 @@
+/**
+ * Analysis Adapter Interface
+ * 
+ * Defines the contract for language/framework-specific adapters
+ * that customize feature and flow detection.
+ */
+
+export interface AnalysisAdapter {
+  /** Unique identifier for the adapter */
+  name: string;
+  
+  /** Human-readable display name */
+  displayName: string;
+  
+  /** File/directory markers that indicate this adapter should be used */
+  detectionSignals: DetectionSignal[];
+  
+  /** Root directories to scan for features */
+  featureRoots: string[];
+  
+  /** Folders to ignore when detecting features */
+  ignoredFolders: string[];
+  
+  /** File name patterns that indicate entrypoints */
+  entrypointPatterns: string[];
+  
+  /** Layer definitions for flow detection */
+  layerRules: LayerRule[];
+  
+  /** Additional file extensions to include */
+  supportedExtensions: string[];
+  
+  /** Patterns for flow entrypoints */
+  flowEntrypointPatterns: string[];
+  
+  /** Patterns to exclude from flows */
+  flowExcludePatterns: string[];
+}
+
+export interface DetectionSignal {
+  /** Type of signal */
+  type: 'file' | 'directory' | 'content';
+  
+  /** Pattern to match */
+  pattern: string;
+  
+  /** Optional: content to match inside file */
+  contentPattern?: string;
+}
+
+export interface LayerRule {
+  /** Layer name */
+  name: string;
+  
+  /** Priority (lower = earlier in flow) */
+  priority: number;
+  
+  /** Patterns that identify this layer */
+  patterns: string[];
+}
+
+/**
+ * Default adapter configuration
+ */
+export const DEFAULT_ADAPTER: AnalysisAdapter = {
+  name: 'default',
+  displayName: 'Default',
+  detectionSignals: [],
+  featureRoots: ['src', 'app', 'lib', 'modules'],
+  ignoredFolders: ['utils', 'helpers', 'types', 'interfaces', 'constants', 'config', 'dto', 'models', 'common', 'shared', 'node_modules', '.git'],
+  entrypointPatterns: ['controller', 'route', 'handler', 'command', 'service'],
+  layerRules: [
+    { name: 'api', priority: 1, patterns: ['controller', 'handler', 'route', 'router', 'api', 'endpoint'] },
+    { name: 'service', priority: 2, patterns: ['service', 'services', 'usecase', 'interactor'] },
+    { name: 'data', priority: 3, patterns: ['repository', 'repo', 'dal', 'dao', 'data', 'persistence'] },
+    { name: 'domain', priority: 4, patterns: ['model', 'entity', 'schema', 'domain'] },
+    { name: 'util', priority: 5, patterns: ['util', 'helper', 'lib', 'common'] }
+  ],
+  supportedExtensions: ['.ts', '.tsx', '.js', '.jsx', '.py', '.java', '.kt', '.go', '.rs', '.rb', '.php', '.cs', '.vue', '.svelte'],
+  flowEntrypointPatterns: ['controller', 'route', 'handler', 'command'],
+  flowExcludePatterns: ['repository', 'repo', 'utils', 'helper', 'model', 'entity', 'dto', 'type', 'interface', 'constant', 'config']
+};

package/src/core/adapters/community/fastapiAdapter.ts

@@ -0,0 +1,50 @@
+/**
+ * FastAPI Adapter
+ * 
+ * Community adapter for Python FastAPI projects
+ */
+
+import { createAdapter, fileSignal, directorySignal, layerRule } from '../sdk.js';
+
+export const fastapiAdapter = createAdapter({
+  name: 'fastapi',
+  displayName: 'FastAPI',
+  
+  detectionSignals: [
+  ],
+  
+  featureRoots: [
+    'app',
+    'app/api',
+    'app/services',
+    'app/models',
+    'app/schemas'
+  ],
+  
+  ignoredFolders: [
+    'venv', '.venv', '__pycache__', '.git',
+    'tests', 'test', '.pytest_cache', 'docs'
+  ],
+  
+  entrypointPatterns: [
+    'router', 'APIRouter', 'endpoint', 'route',
+    'view', 'controller', 'service'
+  ],
+  
+  layerRules: [
+    layerRule('api', 1, ['router', 'APIRouter', 'endpoint', 'route', 'view']),
+    layerRule('service', 2, ['service', 'usecase', 'interactor', 'business']),
+    layerRule('data', 3, ['model', 'schema', 'repository', 'dao']),
+    layerRule('domain', 4, ['entity', 'schema', 'domain']),
+    layerRule('util', 5, ['util', 'helper', 'lib', 'core'])
+  ],
+  
+  supportedExtensions: ['.py'],
+  
+  flowEntrypointPatterns: ['router', 'APIRouter', 'endpoint', 'route'],
+  
+  flowExcludePatterns: [
+    'model', 'schema', 'repository', 'test', 'tests',
+    '__pycache__', 'conftest'
+  ]
+});

package/src/core/adapters/community/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Community Adapters
+ * 
+ * Community-contributed adapters for various frameworks
+ */
+
+export { laravelAdapter } from './laravelAdapter.js';
+export { nestjsAdapter } from './nestjsAdapter.js';
+export { springBootAdapter } from './springBootAdapter.js';
+export { phoenixAdapter } from './phoenixAdapter.js';
+export { fastapiAdapter } from './fastapiAdapter.js';