ai-first-cli 1.1.1 → 1.1.2

package/src/core/lazyAnalyzer.ts

@@ -0,0 +1,261 @@
+import fs from "fs";
+import path from "path";
+import { writeFile, ensureDir } from "../utils/fileUtils.js";
+import { scanRepo } from "./repoScanner.js";
+import { generateRepoMap } from "./repoMapper.js";
+import { detectTechStack } from "../analyzers/techStack.js";
+import { discoverEntrypoints } from "../analyzers/entrypoints.js";
+import { extractSymbols, Symbol } from "../analyzers/symbols.js";
+import { analyzeDependencies, Dependency } from "../analyzers/dependencies.js";
+import { generateSemanticContexts } from "./semanticContexts.js";
+import { buildKnowledgeGraph } from "./knowledgeGraphBuilder.js";
+
+export interface MinimalIndex {
+  repoMap: string;
+  languages: string[];
+  frameworks: string[];
+  entrypoints: string[];
+  generatedAt: string;
+}
+
+export interface LazyIndexState {
+  stage1Complete: boolean;
+  stage2Complete: boolean;
+  featuresExpanded: string[];
+  flowsExpanded: string[];
+  lastUpdated: string;
+}
+
+/**
+ * Build minimal index (Stage 1) - fast startup
+ * Generates only essential metadata needed for basic context
+ */
+export function buildMinimalIndex(rootDir: string, aiDir: string): MinimalIndex {
+  const scanResult = scanRepo(rootDir);
+  const techStack = detectTechStack(scanResult.files, rootDir);
+  const entrypoints = discoverEntrypoints(scanResult.files, rootDir);
+  
+  // Generate minimal repo map
+  const repoMap = generateRepoMap(scanResult.files, { sortBy: "directory" });
+  
+  // Write minimal index files
+  const minimalIndex: MinimalIndex = {
+    repoMap,
+    languages: techStack.languages,
+    frameworks: techStack.frameworks,
+    entrypoints: entrypoints.map(e => e.path),
+    generatedAt: new Date().toISOString()
+  };
+  
+  // Save minimal index state
+  const state: LazyIndexState = {
+    stage1Complete: true,
+    stage2Complete: false,
+    featuresExpanded: [],
+    flowsExpanded: [],
+    lastUpdated: new Date().toISOString()
+  };
+  
+  const statePath = path.join(aiDir, "lazy-index-state.json");
+  writeFile(statePath, JSON.stringify(state, null, 2));
+  
+  // Save minimal data
+  writeFile(path.join(aiDir, "minimal-index.json"), JSON.stringify(minimalIndex, null, 2));
+  
+  return minimalIndex;
+}
+
+/**
+ * Expand context for a specific feature (Stage 2 - on demand)
+ */
+export function expandFeatureContext(
+  rootDir: string, 
+  aiDir: string, 
+  featureName: string
+): { success: boolean; files?: string[]; error?: string } {
+  try {
+    const scanResult = scanRepo(rootDir);
+    const symbols = extractSymbols(scanResult.files);
+    
+    // Filter symbols related to this feature
+    const featureSymbols = symbols.symbols.filter((s: Symbol) => 
+      s.file.includes(featureName) || s.name.toLowerCase().includes(featureName.toLowerCase())
+    );
+    
+    // Load existing state
+    const statePath = path.join(aiDir, "lazy-index-state.json");
+    let state: LazyIndexState = {
+      stage1Complete: true,
+      stage2Complete: false,
+      featuresExpanded: [],
+      flowsExpanded: [],
+      lastUpdated: new Date().toISOString()
+    };
+    
+    if (fs.existsSync(statePath)) {
+      state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+    }
+    
+    // Mark feature as expanded
+    if (!state.featuresExpanded.includes(featureName)) {
+      state.featuresExpanded.push(featureName);
+      state.lastUpdated = new Date().toISOString();
+      writeFile(statePath, JSON.stringify(state, null, 2));
+    }
+    
+    // Generate feature context file
+    const featureContextPath = path.join(aiDir, "context", "features", `${featureName}.json`);
+    const featureContext = {
+      feature: featureName,
+      symbols: featureSymbols,
+      generatedAt: new Date().toISOString()
+    };
+    
+    ensureDir(path.dirname(featureContextPath));
+    writeFile(featureContextPath, JSON.stringify(featureContext, null, 2));
+    
+    return { success: true, files: featureSymbols.map((s: Symbol) => s.file) };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : String(error) 
+    };
+  }
+}
+
+/**
+ * Expand context for a specific flow (Stage 2 - on demand)
+ */
+export function expandFlowContext(
+  rootDir: string, 
+  aiDir: string, 
+  flowName: string
+): { success: boolean; files?: string[]; error?: string } {
+  try {
+    const scanResult = scanRepo(rootDir);
+    const dependencies = analyzeDependencies(scanResult.files);
+    
+    // Find files related to this flow
+    const flowFiles = dependencies.dependencies
+      .filter((d: Dependency) => d.source.includes(flowName) || d.target.includes(flowName))
+      .flatMap((d: Dependency) => [d.source, d.target]);
+    
+    // Load existing state
+    const statePath = path.join(aiDir, "lazy-index-state.json");
+    let state: LazyIndexState = {
+      stage1Complete: true,
+      stage2Complete: false,
+      featuresExpanded: [],
+      flowsExpanded: [],
+      lastUpdated: new Date().toISOString()
+    };
+    
+    if (fs.existsSync(statePath)) {
+      state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+    }
+    
+    // Mark flow as expanded
+    if (!state.flowsExpanded.includes(flowName)) {
+      state.flowsExpanded.push(flowName);
+      state.lastUpdated = new Date().toISOString();
+      writeFile(statePath, JSON.stringify(state, null, 2));
+    }
+    
+    // Generate flow context file
+    const flowContextPath = path.join(aiDir, "context", "flows", `${flowName}.json`);
+    const flowContext = {
+      name: flowName,
+      files: [...new Set(flowFiles)],
+      generatedAt: new Date().toISOString()
+    };
+    
+    ensureDir(path.dirname(flowContextPath));
+    writeFile(flowContextPath, JSON.stringify(flowContext, null, 2));
+    
+    return { success: true, files: [...new Set(flowFiles)] };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : String(error) 
+    };
+  }
+}
+
+/**
+ * Expand full context (Stage 2) - when needed
+ */
+export function expandFullContext(rootDir: string, aiDir: string): {
+  symbols: number;
+  dependencies: number;
+  features: number;
+  flows: number;
+} {
+  const scanResult = scanRepo(rootDir);
+  
+  // Extract symbols
+  const symbols = extractSymbols(scanResult.files);
+  const symbolsPath = path.join(aiDir, "symbols.json");
+  writeFile(symbolsPath, JSON.stringify(symbols, null, 2));
+  
+  // Analyze dependencies
+  const dependencies = analyzeDependencies(scanResult.files);
+  const depsPath = path.join(aiDir, "dependencies.json");
+  writeFile(depsPath, JSON.stringify(dependencies, null, 2));
+  
+  // Generate semantic contexts
+  const { features, flows } = generateSemanticContexts(aiDir);
+  
+  // Build knowledge graph
+  buildKnowledgeGraph(rootDir, aiDir);
+  
+  // Update state
+  const statePath = path.join(aiDir, "lazy-index-state.json");
+  const state: LazyIndexState = {
+    stage1Complete: true,
+    stage2Complete: true,
+    featuresExpanded: Array.isArray(features) ? features.map((f: any) => f.name || f.feature || String(f)) : [],
+    flowsExpanded: Array.isArray(flows) ? flows.map((f: any) => f.name || f.flow || String(f)) : [],
+    lastUpdated: new Date().toISOString()
+  };
+  writeFile(statePath, JSON.stringify(state, null, 2));
+  
+  return {
+    symbols: symbols.symbols?.length || 0,
+    dependencies: dependencies.dependencies?.length || 0,
+    features: features.length,
+    flows: flows.length
+  };
+}
+
+/**
+ * Get lazy index state
+ */
+export function getLazyIndexState(aiDir: string): LazyIndexState | null {
+  const statePath = path.join(aiDir, "lazy-index-state.json");
+  if (!fs.existsSync(statePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if minimal index exists
+ */
+export function hasMinimalIndex(aiDir: string): boolean {
+  return fs.existsSync(path.join(aiDir, "minimal-index.json"));
+}
+
+/**
+ * Load minimal index
+ */
+export function loadMinimalIndex(aiDir: string): MinimalIndex | null {
+  const indexPath = path.join(aiDir, "minimal-index.json");
+  if (!fs.existsSync(indexPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}

package/src/core/schema.ts

@@ -0,0 +1,157 @@
+/**
+ * AI Repository Schema System
+ * 
+ * Defines the standard schema for AI-First repository metadata.
+ */
+
+import fs from "fs";
+import path from "path";
+import { writeFile, readJsonFile } from "../utils/fileUtils.js";
+
+export const SCHEMA_VERSION = "1.0";
+export const GENERATED_BY = "ai-first";
+
+export interface SchemaInfo {
+  schemaVersion: string;
+  generatedBy: string;
+  generatedAt: string;
+}
+
+export interface ProjectInfo {
+  name: string;
+  rootDir: string;
+  features: string[];
+  flows: string[];
+  languages: string[];
+  frameworks: string[];
+  generatedAt: string;
+}
+
+export interface ToolsInfo {
+  compatibleAgents: string[];
+  schemaVersion: string;
+}
+
+export interface AISchema {
+  schema: SchemaInfo;
+  project: ProjectInfo;
+  tools: ToolsInfo;
+}
+
+export function generateSchema(aiDir: string): SchemaInfo {
+  const schema: SchemaInfo = {
+    schemaVersion: SCHEMA_VERSION,
+    generatedBy: GENERATED_BY,
+    generatedAt: new Date().toISOString()
+  };
+  writeFile(path.join(aiDir, "schema.json"), JSON.stringify(schema, null, 2));
+  return schema;
+}
+
+export function generateProject(rootDir: string, aiDir: string, options: {
+  name?: string;
+  features?: string[];
+  flows?: string[];
+  languages?: string[];
+  frameworks?: string[];
+} = {}): ProjectInfo {
+  const name = options.name || path.basename(rootDir);
+  
+  let features = options.features || [];
+  const featuresDir = path.join(aiDir, "context", "features");
+  if (fs.existsSync(featuresDir) && features.length === 0) {
+    try {
+      features = fs.readdirSync(featuresDir).filter(f => f.endsWith(".json")).map(f => f.replace(".json", ""));
+    } catch { /* ignore */ }
+  }
+  
+  let flows = options.flows || [];
+  const flowsDir = path.join(aiDir, "context", "flows");
+  if (fs.existsSync(flowsDir) && flows.length === 0) {
+    try {
+      flows = fs.readdirSync(flowsDir).filter(f => f.endsWith(".json")).map(f => f.replace(".json", ""));
+    } catch { /* ignore */ }
+  }
+  
+  let languages = options.languages || [];
+  let frameworks = options.frameworks || [];
+  const techStackPath = path.join(aiDir, "tech_stack.md");
+  if (fs.existsSync(techStackPath)) {
+    try {
+      const content = fs.readFileSync(techStackPath, "utf-8");
+      const langMatch = content.match(/Languages?:\s*([^\n]+)/i);
+      if (langMatch) languages = langMatch[1].split(",").map(s => s.trim()).filter(Boolean);
+      const fwMatch = content.match(/Frameworks?:\s*([^\n]+)/i);
+      if (fwMatch) frameworks = fwMatch[1].split(",").map(s => s.trim()).filter(Boolean);
+    } catch { /* ignore */ }
+  }
+  
+  const project: ProjectInfo = { name, rootDir, features, flows, languages, frameworks, generatedAt: new Date().toISOString() };
+  writeFile(path.join(aiDir, "project.json"), JSON.stringify(project, null, 2));
+  return project;
+}
+
+export function generateTools(aiDir: string): ToolsInfo {
+  const tools: ToolsInfo = {
+    compatibleAgents: ["ai-first-bridge", "opencode", "cursor", "windsurf", "cline"],
+    schemaVersion: SCHEMA_VERSION
+  };
+  writeFile(path.join(aiDir, "tools.json"), JSON.stringify(tools, null, 2));
+  return tools;
+}
+
+export function generateAllSchema(rootDir: string, aiDir: string, options: {
+  projectName?: string;
+  features?: string[];
+  flows?: string[];
+  languages?: string[];
+  frameworks?: string[];
+} = {}): AISchema {
+  return {
+    schema: generateSchema(aiDir),
+    project: generateProject(rootDir, aiDir, options),
+    tools: generateTools(aiDir)
+  };
+}
+
+export function loadSchema(aiDir: string): SchemaInfo | null {
+  const p = path.join(aiDir, "schema.json");
+  if (!fs.existsSync(p)) return null;
+  try { return readJsonFile(p) as unknown as SchemaInfo; } catch { return null; }
+}
+
+export function loadProject(aiDir: string): ProjectInfo | null {
+  const p = path.join(aiDir, "project.json");
+  if (!fs.existsSync(p)) return null;
+  try { return readJsonFile(p) as unknown as ProjectInfo; } catch { return null; }
+}
+
+export function loadTools(aiDir: string): ToolsInfo | null {
+  const p = path.join(aiDir, "tools.json");
+  if (!fs.existsSync(p)) return null;
+  try { return readJsonFile(p) as unknown as ToolsInfo; } catch { return null; }
+}
+
+export function loadFullSchema(aiDir: string): AISchema | null {
+  const schema = loadSchema(aiDir);
+  const project = loadProject(aiDir);
+  const tools = loadTools(aiDir);
+  if (!schema || !project || !tools) return null;
+  return { schema, project, tools };
+}
+
+export function isCompatible(targetVersion: string): boolean {
+  const [targetMajor] = targetVersion.split(".").map(Number);
+  const [schemaMajor] = SCHEMA_VERSION.split(".").map(Number);
+  return targetMajor === schemaMajor;
+}
+
+export function validateSchema(aiDir: string): { valid: boolean; version?: string; errors: string[] } {
+  const errors: string[] = [];
+  const schema = loadSchema(aiDir);
+  if (!schema) errors.push("schema.json not found");
+  else if (!isCompatible(schema.schemaVersion)) errors.push(`Incompatible schema version: ${schema.schemaVersion}`);
+  if (!loadProject(aiDir)) errors.push("project.json not found");
+  if (!loadTools(aiDir)) errors.push("tools.json not found");
+  return { valid: errors.length === 0, version: schema?.schemaVersion, errors };
+}