ai-first-cli 1.3.5 → 1.3.8

package/src/commands/ai-first.ts

@@ -31,6 +31,7 @@ import { runIncrementalUpdate, detectChangedFiles } from "../core/incrementalAna
 import { generateAllSchema } from "../core/schema.js";
 import { Database } from "sql.js";
 import ora from "ora";
+import { startMCP } from "../mcp/index.js";
 import process from "process";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -1077,6 +1078,8 @@ Options:
   } else if (command === 'init' || !command) {
     // Init command - generate all context files
     if (command === 'init') args.shift();
+    
+    let preset: string | undefined;
 
     for (let i = 0; i < args.length; i++) {
       const arg = args[i];
@@ -1089,6 +1092,10 @@ Options:
         case "-o":
           options.outputDir = args[++i];
           break;
+        case "--preset":
+        case "-p":
+          preset = args[++i];
+          break;
         case "--help":
         case "-h":
           console.log(`
@@ -1106,18 +1113,45 @@ 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)
+  adapters             List available adapters
+  git                  Show git activity and recent changes
+  graph                Build knowledge graph
+  update               Update context incrementally
+  mcp                  Start MCP server for AI agents
 
 Options:
   -r, --root <dir>      Root directory to scan (default: current directory)
   -o, --output <dir>   Output directory (default: ./ai-context)
+  -p, --preset <name>  Use preset (full, quick, api, docs)
   -h, --help           Show help message
+
+Presets:
+  full    Complete analysis with all features
+  quick   Fast analysis for development iterations
+  api     Focus on API endpoints and services
+  docs    Documentation files only
 `);
           process.exit(0);
       }
     }
+    
+    const rootDir = options.rootDir || process.cwd();
+    const configPath = path.join(rootDir, 'ai-first.config.json');
+    if (fs.existsSync(configPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        if (config.output?.directory && !options.outputDir) {
+          options.outputDir = path.join(rootDir, config.output.directory);
+        }
+        if (config.preset && !preset) {
+          preset = config.preset;
+        }
+      } catch {}
+    }
+    
+    if (preset) {
+      console.log(`\n🎛️  Using preset: ${preset}\n`);
+    }
 
     runAIFirst(options).then((result) => {
       process.exit(result.success ? 0 : 1);
@@ -1491,7 +1525,52 @@ Examples:
     }
     
     process.exit(0);
-    process.exit(0);
+  } else if (command === 'mcp') {
+    // MCP command - start Model Context Protocol server
+    args.shift();
+    
+    if (args.includes('--help') || args.includes('-h')) {
+      console.log(`
+ai-first mcp - Start Model Context Protocol server
+
+Usage: ai-first mcp [options]
+
+Options:
+  -r, --root <dir>    Root directory to scan (default: current directory)
+  -h, --help          Show help message
+
+Description:
+  Starts an MCP server that allows AI agents (Claude Desktop, etc.) to
+  query repository context using the Model Context Protocol.
+
+The server provides these tools:
+  - generate_context: Generate AI context for the repository
+  - index_repo: Create SQLite index for fast queries
+  - query_symbol: Look up symbols by name
+  - get_architecture: Get architecture analysis
+  - get_tech_stack: Get technology stack information
+
+Examples:
+  ai-first mcp                    # Start MCP server in current directory
+  ai-first mcp --root ./my-project # Start with specific root directory
+`);
+      process.exit(0);
+    }
+    
+    let rootDir = process.cwd();
+    
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--root" || arg === "-r") rootDir = args[++i];
+    }
+    
+    console.log("\n🚀 Starting MCP server...\n");
+    console.log(`   Root directory: ${rootDir}`);
+    console.log("   Protocol: stdio");
+    console.log("\n   The server is now running and ready to accept MCP requests.");
+    console.log("   Use Ctrl+C to stop.\n");
+    
+    startMCP({ rootDir });
   } else {
     console.log(`Unknown command: ${command}`);
     console.log(`Use 'ai-first --help' for usage information`);

package/src/config/configLoader.ts

@@ -0,0 +1,274 @@
+import fs from 'fs';
+import path from 'path';
+import type {
+  AIFirstConfig,
+  AnalysisPreset,
+  ConfigLoadOptions,
+  ConfigLoadResult,
+  PresetConfig,
+  ValidationResult,
+  ValidationError,
+  ValidationWarning,
+  OutputConfig,
+  IndexConfig,
+} from './types.js';
+
+const DEFAULT_CONFIG_PATH = 'ai-first.config.json';
+
+const PRESETS: Record<AnalysisPreset, PresetConfig> = {
+  full: {
+    name: 'full',
+    description: 'Full analysis with all analyzers enabled',
+    analysis: {
+      detailLevel: 'full',
+      inclusionLevel: 'full',
+      analyzers: {
+        architecture: { enabled: true },
+        techStack: { enabled: true },
+        entrypoints: { enabled: true },
+        conventions: { enabled: true },
+        symbols: { enabled: true },
+        dependencies: { enabled: true },
+        aiRules: { enabled: true },
+      },
+    },
+    output: {
+      directory: 'ai-context',
+      formats: ['md', 'json'],
+      prettyPrint: true,
+      includeMetadata: true,
+    },
+    index: {
+      enabled: true,
+      type: 'sqlite',
+      incremental: true,
+    },
+  },
+  quick: {
+    name: 'quick',
+    description: 'Fast analysis with basic information',
+    analysis: {
+      detailLevel: 'skeleton',
+      inclusionLevel: 'directory',
+      maxFileSize: 10000,
+      analyzers: {
+        architecture: { enabled: true },
+        techStack: { enabled: true },
+        entrypoints: { enabled: true },
+        conventions: { enabled: false },
+        symbols: { enabled: false },
+        dependencies: { enabled: false },
+        aiRules: { enabled: false },
+      },
+    },
+    output: {
+      directory: 'ai-context',
+      formats: ['md'],
+      prettyPrint: false,
+      includeMetadata: false,
+    },
+    index: {
+      enabled: false,
+      type: 'memory',
+    },
+  },
+  api: {
+    name: 'api',
+    description: 'Focused on API and backend analysis',
+    analysis: {
+      detailLevel: 'signatures',
+      inclusionLevel: 'compress',
+      analyzers: {
+        architecture: { enabled: true },
+        techStack: { enabled: true },
+        entrypoints: { enabled: true },
+        conventions: { enabled: true },
+        symbols: { enabled: true },
+        dependencies: { enabled: true },
+        aiRules: { enabled: false },
+      },
+    },
+    output: {
+      directory: 'ai-context',
+      formats: ['md', 'json'],
+      prettyPrint: true,
+      includeMetadata: true,
+    },
+    index: {
+      enabled: true,
+      type: 'sqlite',
+      incremental: true,
+    },
+  },
+  docs: {
+    name: 'docs',
+    description: 'Generate documentation-focused output',
+    analysis: {
+      detailLevel: 'full',
+      inclusionLevel: 'full',
+      analyzers: {
+        architecture: { enabled: true },
+        techStack: { enabled: true },
+        entrypoints: { enabled: true },
+        conventions: { enabled: true },
+        symbols: { enabled: true },
+        dependencies: { enabled: false },
+        aiRules: { enabled: false },
+      },
+    },
+    output: {
+      directory: 'ai-context',
+      formats: ['md', 'html'],
+      prettyPrint: true,
+      includeMetadata: true,
+    },
+    index: {
+      enabled: false,
+      type: 'memory',
+    },
+  },
+};
+
+const DEFAULT_CONFIG: AIFirstConfig = {
+  version: '1.0.0',
+  preset: 'full',
+  analysis: PRESETS.full.analysis as NonNullable<AIFirstConfig['analysis']>,
+  output: PRESETS.full.output as OutputConfig,
+  index: PRESETS.full.index as IndexConfig,
+};
+
+function validateConfig(config: unknown): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationWarning[] = [];
+
+  if (!config || typeof config !== 'object') {
+    errors.push({ field: 'root', message: 'Config must be an object' });
+    return { valid: false, errors, warnings };
+  }
+
+  const cfg = config as Record<string, unknown>;
+
+  if (!cfg.version || typeof cfg.version !== 'string') {
+    errors.push({ field: 'version', message: 'Version is required and must be a string' });
+  }
+
+  if (cfg.preset !== undefined) {
+    const validPresets: AnalysisPreset[] = ['full', 'quick', 'api', 'docs'];
+    if (!validPresets.includes(cfg.preset as AnalysisPreset)) {
+      errors.push({
+        field: 'preset',
+        message: `Invalid preset. Must be one of: ${validPresets.join(', ')}`,
+        value: cfg.preset,
+      });
+    }
+  }
+
+  if (cfg.analysis && typeof cfg.analysis !== 'object') {
+    errors.push({ field: 'analysis', message: 'Analysis must be an object' });
+  }
+
+  if (cfg.output && typeof cfg.output !== 'object') {
+    errors.push({ field: 'output', message: 'Output must be an object' });
+  }
+
+  if (cfg.index && typeof cfg.index !== 'object') {
+    errors.push({ field: 'index', message: 'Index must be an object' });
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+function mergeConfig(base: AIFirstConfig, override: Partial<AIFirstConfig>): AIFirstConfig {
+  const result: AIFirstConfig = {
+    ...base,
+    ...override,
+  };
+
+  if (override.analysis) {
+    result.analysis = { ...base.analysis, ...override.analysis };
+  }
+  if (override.output) {
+    result.output = { ...base.output, ...override.output } as OutputConfig;
+  }
+  if (override.index) {
+    result.index = { ...base.index, ...override.index } as IndexConfig;
+  }
+
+  return result;
+}
+
+export function getPreset(name: AnalysisPreset): PresetConfig | undefined {
+  return PRESETS[name];
+}
+
+export function listPresets(): PresetConfig[] {
+  return Object.values(PRESETS);
+}
+
+export function loadConfig(options: ConfigLoadOptions = {}): ConfigLoadResult {
+  const {
+    configPath = DEFAULT_CONFIG_PATH,
+    preset,
+    overrides,
+    validate = true,
+    throwOnError = false,
+  } = options;
+
+  let config: AIFirstConfig = { ...DEFAULT_CONFIG };
+  let source: ConfigLoadResult['source'] = 'default';
+
+  if (fs.existsSync(configPath)) {
+    try {
+      const fileContent = fs.readFileSync(configPath, 'utf-8');
+      const loadedConfig = JSON.parse(fileContent) as Partial<AIFirstConfig>;
+      config = mergeConfig(DEFAULT_CONFIG, loadedConfig);
+      source = 'file';
+    } catch (error) {
+      const parseError: ValidationError = {
+        field: 'configFile',
+        message: `Failed to parse config file: ${error instanceof Error ? error.message : String(error)}`,
+        value: configPath,
+      };
+      if (throwOnError) {
+        throw new Error(parseError.message);
+      }
+      return {
+        config: DEFAULT_CONFIG,
+        source: 'default',
+        validation: { valid: false, errors: [parseError], warnings: [] },
+      };
+    }
+  }
+
+  if (preset && PRESETS[preset]) {
+    const p = PRESETS[preset];
+    const presetData: Partial<AIFirstConfig> = {
+      analysis: p.analysis as AIFirstConfig['analysis'],
+      output: p.output as AIFirstConfig['output'],
+      index: p.index as AIFirstConfig['index'],
+    };
+    config = mergeConfig(config, presetData);
+    source = source === 'default' ? 'preset' : 'merged';
+  }
+
+  if (overrides) {
+    config = mergeConfig(config, overrides);
+    source = 'merged';
+  }
+
+  const validation = validateConfig(config);
+
+  if (!validation.valid && throwOnError) {
+    const errorMessages = validation.errors.map(e => e.message).join('; ');
+    throw new Error(`Configuration validation failed: ${errorMessages}`);
+  }
+
+  return { config, source, validation };
+}
+
+export function resolveConfigPath(customPath?: string): string {
+  if (customPath) {
+    return path.resolve(customPath);
+  }
+  return path.resolve(DEFAULT_CONFIG_PATH);
+}

package/src/config/index.ts

@@ -0,0 +1,27 @@
+export type {
+  AnalysisPreset,
+  ConfigDetailLevel,
+  ConfigInclusionLevel,
+  FilePatternConfig,
+  AnalyzerConfig,
+  AnalysisConfig,
+  FileInclusionConfig,
+  OutputConfig,
+  GitConfig,
+  IndexConfig,
+  ContextConfig,
+  PresetConfig,
+  AIFirstConfig,
+  ValidationResult,
+  ValidationError,
+  ValidationWarning,
+  ConfigLoadOptions,
+  ConfigLoadResult,
+} from './types.js';
+
+export {
+  loadConfig,
+  getPreset,
+  listPresets,
+  resolveConfigPath,
+} from './configLoader.js';

package/src/config/types.ts

@@ -0,0 +1,117 @@
+export type AnalysisPreset = 'full' | 'quick' | 'api' | 'docs';
+
+export type ConfigDetailLevel = 'full' | 'signatures' | 'skeleton';
+
+export type ConfigInclusionLevel = 'full' | 'compress' | 'directory' | 'exclude';
+
+export interface FilePatternConfig {
+  include?: string[];
+  exclude?: string[];
+}
+
+export interface AnalyzerConfig {
+  enabled: boolean;
+  options?: Record<string, unknown>;
+}
+
+export interface AnalysisConfig {
+  preset?: AnalysisPreset;
+  detailLevel?: ConfigDetailLevel;
+  inclusionLevel?: ConfigInclusionLevel;
+  filePatterns?: FilePatternConfig;
+  maxFileSize?: number;
+  includePatterns?: string[];
+  excludePatterns?: string[];
+  analyzers?: {
+    architecture?: AnalyzerConfig;
+    techStack?: AnalyzerConfig;
+    entrypoints?: AnalyzerConfig;
+    conventions?: AnalyzerConfig;
+    symbols?: AnalyzerConfig;
+    dependencies?: AnalyzerConfig;
+    aiRules?: AnalyzerConfig;
+  };
+}
+
+export interface FileInclusionConfig {
+  level: ConfigInclusionLevel;
+  patterns: string[];
+  maxFileSize?: number;
+}
+
+export interface OutputConfig {
+  directory: string;
+  formats: ('md' | 'json' | 'html')[];
+  prettyPrint?: boolean;
+  includeMetadata?: boolean;
+}
+
+export interface GitConfig {
+  includeCommits?: number;
+  excludePatterns?: string[];
+}
+
+export interface IndexConfig {
+  enabled: boolean;
+  type: 'sqlite' | 'memory';
+  incremental?: boolean;
+  watch?: boolean;
+}
+
+export interface ContextConfig {
+  maxTokens?: number;
+  includeEmbeddings?: boolean;
+  semanticSearch?: boolean;
+  maxResults?: number;
+}
+
+export interface PresetConfig {
+  name: AnalysisPreset;
+  description: string;
+  analysis: Partial<AnalysisConfig>;
+  output: Partial<OutputConfig>;
+  index: Partial<IndexConfig>;
+}
+
+export interface AIFirstConfig {
+  version: string;
+  preset?: AnalysisPreset;
+  analysis?: AnalysisConfig;
+  output?: OutputConfig;
+  index?: IndexConfig;
+  context?: ContextConfig;
+  git?: GitConfig;
+  fileInclusion?: FileInclusionConfig;
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+  warnings: ValidationWarning[];
+}
+
+export interface ValidationError {
+  field: string;
+  message: string;
+  value?: unknown;
+}
+
+export interface ValidationWarning {
+  field: string;
+  message: string;
+  suggestion?: string;
+}
+
+export interface ConfigLoadOptions {
+  configPath?: string;
+  preset?: AnalysisPreset;
+  overrides?: Partial<AIFirstConfig>;
+  validate?: boolean;
+  throwOnError?: boolean;
+}
+
+export interface ConfigLoadResult {
+  config: AIFirstConfig;
+  source: 'default' | 'file' | 'preset' | 'merged';
+  validation: ValidationResult;
+}