ai-first-cli 1.3.6 → 1.3.8

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;
+}

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