@baselineos/lang 0.1.0

package/src/system.ts

@@ -0,0 +1,1025 @@
+/**
+ * Baseline Lang System
+ *
+ * The foundation layer of the Baseline Protocol that handles natural language
+ * processing, command interpretation, and language syntax management.
+ *
+ * @license Apache-2.0
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import langSystemConfig from './config/lang-system-config.json' with { type: 'json' };
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export interface LangSystemConfig {
+  language: string;
+  syntax: SyntaxConfig;
+  patterns: PatternConfig;
+  commands: Record<string, CommandConfig>;
+  lexicon?: Record<string, LexiconEntry>;
+  validation?: LangValidationConfig;
+}
+
+export interface SyntaxConfig {
+  commandPrefix: string;
+  optionPrefix: string;
+  separator: string;
+  quoteChar: string;
+}
+
+export interface PatternConfig {
+  intent: RegExp;
+  command: RegExp;
+  option: RegExp;
+  value: RegExp;
+}
+
+export interface LangValidationConfig {
+  allowUnknownOptions?: boolean;
+}
+
+export interface CommandOptionSpec {
+  type?: 'string' | 'number' | 'boolean';
+  description?: string;
+  required?: boolean;
+  default?: unknown;
+  values?: string[];
+}
+
+export interface CommandValidationSpec {
+  minArgs?: number;
+  maxArgs?: number;
+  allowUnknownOptions?: boolean;
+}
+
+export interface LexiconEntry {
+  description: string;
+  aliases?: string[];
+  tags?: string[];
+  examples?: string[];
+  source?: string;
+}
+
+export interface CommandConfig {
+  aliases: string[];
+  description: string;
+  usage: string;
+  examples: string[];
+  handler?: CommandHandler;
+  options?: Record<string, CommandOptionSpec>;
+  validation?: CommandValidationSpec;
+}
+
+export interface RegisteredCommand {
+  name: string;
+  aliases: string[];
+  description: string;
+  usage: string;
+  examples: string[];
+  handler: CommandHandler;
+  options: Record<string, CommandOptionSpec>;
+  validation: CommandValidationSpec;
+}
+
+export type CommandHandler = (
+  command: string,
+  options: Map<string, unknown>,
+  args: string[],
+) => CommandResult;
+
+export interface CommandResult {
+  success: boolean;
+  message?: string;
+  error?: string;
+  options?: Map<string, unknown>;
+  arguments?: string[];
+  suggestions?: string[];
+  timestamp?: string;
+}
+
+export interface ParsedInput {
+  original: string;
+  tokens: string[];
+  command: string | null;
+  options: Map<string, unknown>;
+  arguments: string[];
+  intent: string | null;
+}
+
+export interface IntentResult {
+  type: string;
+  confidence: number;
+  patterns: RegExp[];
+}
+
+export interface ProcessResult {
+  success: boolean;
+  input?: string;
+  parsed?: ParsedInput;
+  intent?: IntentResult;
+  result?: CommandResult;
+  error?: string;
+  details?: string | string[];
+  suggestions?: string[];
+  timestamp?: string;
+}
+
+export interface ParsedOption {
+  name: string;
+  value: string | null;
+  type: 'long' | 'short' | 'unknown';
+}
+
+export interface BaselineLangOptions {
+  projectRoot?: string;
+  projectLexicon?: Record<string, LexiconEntry>;
+}
+
+// ─── Intent Recognizer ──────────────────────────────────────────────
+
+export class IntentRecognizer {
+  private patterns = new Map<string, Record<string, RegExp>>();
+
+  initialize(patterns: Record<string, unknown>): void {
+    // Store patterns — the config may have flat RegExp values or nested objects
+    for (const [key, value] of Object.entries(patterns)) {
+      if (value instanceof RegExp) {
+        this.patterns.set(key, { default: value });
+      } else if (typeof value === 'object' && value !== null) {
+        this.patterns.set(key, value as Record<string, RegExp>);
+      }
+    }
+  }
+
+  recognize(parsed: ParsedInput): IntentResult {
+    const intent: IntentResult = {
+      type: 'unknown',
+      confidence: 0,
+      patterns: [],
+    };
+
+    if (parsed.command) {
+      const commandIntent = this.analyzeCommand(parsed.command);
+      if (commandIntent.confidence > intent.confidence) {
+        intent.type = commandIntent.type;
+        intent.confidence = commandIntent.confidence;
+        intent.patterns = commandIntent.patterns;
+      }
+    }
+
+    if (parsed.arguments.length > 0) {
+      const argIntent = this.analyzeArguments(parsed.arguments);
+      if (argIntent.confidence > intent.confidence) {
+        intent.type = argIntent.type;
+        intent.confidence = argIntent.confidence;
+        intent.patterns = argIntent.patterns;
+      }
+    }
+
+    return intent;
+  }
+
+  private analyzeCommand(command: string): IntentResult {
+    const patterns = (this.patterns.get('intent') as Record<string, RegExp>) || {};
+    let bestMatch: IntentResult = { type: 'unknown', confidence: 0, patterns: [] };
+
+    for (const [type, pattern] of Object.entries(patterns)) {
+      if (pattern.test(command)) {
+        bestMatch = { type, confidence: 0.8, patterns: [pattern] };
+        break;
+      }
+    }
+
+    return bestMatch;
+  }
+
+  private analyzeArguments(args: string[]): IntentResult {
+    const patterns = (this.patterns.get('intent') as Record<string, RegExp>) || {};
+    let bestMatch: IntentResult = { type: 'unknown', confidence: 0, patterns: [] };
+
+    for (const arg of args) {
+      for (const [type, pattern] of Object.entries(patterns)) {
+        if (pattern.test(arg)) {
+          bestMatch = { type, confidence: 0.6, patterns: [pattern] };
+          break;
+        }
+      }
+      if (bestMatch.type !== 'unknown') break;
+    }
+
+    return bestMatch;
+  }
+}
+
+// ─── Command Processor ──────────────────────────────────────────────
+
+export class CommandProcessor {
+  commandRegistry: Map<string, RegisteredCommand> | null = null;
+
+  process(
+    parsed: ParsedInput,
+    _intent: IntentResult,
+  ): CommandResult {
+    const command = this.findCommand(parsed.command);
+
+    if (!command) {
+      return {
+        success: false,
+        error: `Command "${parsed.command}" not found`,
+        suggestions: ['Use "help" to see available commands'],
+      };
+    }
+
+    try {
+      const result = command.handler(parsed.command!, parsed.options, parsed.arguments);
+      return { ...result };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: `Command execution failed: ${msg}`,
+      };
+    }
+  }
+
+  private findCommand(commandName: string | null): RegisteredCommand | null {
+    if (!commandName || !this.commandRegistry) return null;
+
+    if (this.commandRegistry.has(commandName)) {
+      return this.commandRegistry.get(commandName)!;
+    }
+
+    for (const [, command] of this.commandRegistry) {
+      if (command.aliases.includes(commandName)) {
+        return command;
+      }
+    }
+
+    return null;
+  }
+}
+
+// ─── Syntax Validator ───────────────────────────────────────────────
+
+export class SyntaxValidator {
+  validate(parsed: ParsedInput): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!parsed.command) {
+      errors.push('No command specified');
+    }
+
+    if (parsed.options.size > 0) {
+      for (const [option] of parsed.options) {
+        if (!this.isValidOption(option)) {
+          errors.push(`Invalid option: ${option}`);
+        }
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  private isValidOption(option: string): boolean {
+    return /^[a-z][a-z0-9-]*$/i.test(option);
+  }
+}
+
+// ─── Baseline Lang System ───────────────────────────────────────────
+
+export class BaselineLangSystem {
+  private config: LangSystemConfig;
+  private commandRegistry = new Map<string, RegisteredCommand>();
+  private languagePatterns = new Map<string, Record<string, RegExp>>();
+  private intentRecognizer = new IntentRecognizer();
+  private commandProcessor = new CommandProcessor();
+  private syntaxValidator = new SyntaxValidator();
+  private lexicon = new Map<string, LexiconEntry>();
+  private validationDefaults: Required<LangValidationConfig> = {
+    allowUnknownOptions: true,
+  };
+
+  constructor(options: BaselineLangOptions = {}) {
+    this.config = this.loadConfiguration();
+    this.initializeSystem();
+    if (options.projectLexicon) {
+      this.mergeLexicon(options.projectLexicon, 'project');
+    }
+    if (options.projectRoot) {
+      this.loadProjectLexicon(options.projectRoot);
+    }
+  }
+
+  private loadConfiguration(): LangSystemConfig {
+    const cfg = langSystemConfig as {
+      system?: Record<string, string>;
+      syntax?: Record<string, string>;
+      patterns?: { intent?: Record<string, string>; command?: Record<string, string>; option?: Record<string, string>; value?: Record<string, string> };
+      commands?: Record<string, {
+        aliases?: string[];
+        description?: string;
+        usage?: string;
+        examples?: string[];
+        options?: Record<string, CommandOptionSpec>;
+        validation?: CommandValidationSpec;
+      }>;
+      lexicon?: Record<string, LexiconEntry>;
+      validation?: LangValidationConfig;
+    };
+
+    const syntaxCfg = cfg.syntax ?? {};
+    const patternsCfg = cfg.patterns ?? {};
+    const commandsCfg = cfg.commands ?? {};
+
+    // Build intent regex from config's intent patterns (combine all intent types)
+    const intentPatterns = patternsCfg.intent ?? {};
+    const intentSources = Object.values(intentPatterns);
+    const combinedIntent = intentSources.length > 0
+      ? new RegExp(intentSources.map((p) => `(${p})`).join('|'), 'i')
+      : /^(what|how|when|where|why|who|which|can|should|will|do|does|is|are|was|were)/i;
+
+    return {
+      language: (cfg.system?.language as string) ?? 'en',
+      syntax: {
+        commandPrefix: syntaxCfg.commandPrefix ?? '--',
+        optionPrefix: syntaxCfg.optionPrefix ?? '-',
+        separator: syntaxCfg.separator ?? ' ',
+        quoteChar: syntaxCfg.quoteChar ?? '"',
+      },
+      patterns: {
+        intent: combinedIntent,
+        command: new RegExp(patternsCfg.command?.basic ?? '^[a-z][a-z0-9-]*$', 'i'),
+        option: new RegExp(patternsCfg.option?.long ?? '^[a-z][a-z0-9-]*$', 'i'),
+        value: new RegExp(patternsCfg.value?.text ?? '^[a-zA-Z0-9\\s\\-_./\\\\]+$'),
+      },
+      commands: Object.fromEntries(
+        Object.entries(commandsCfg).map(([name, cmd]) => [
+          name,
+          {
+            aliases: cmd.aliases ?? [],
+            description: cmd.description ?? '',
+            usage: cmd.usage ?? '',
+            examples: cmd.examples ?? [],
+            options: cmd.options ?? {},
+            validation: cmd.validation ?? {},
+          },
+        ])
+      ),
+      lexicon: cfg.lexicon ?? {},
+      validation: {
+        allowUnknownOptions: cfg.validation?.allowUnknownOptions ?? this.validationDefaults.allowUnknownOptions,
+      },
+    };
+  }
+
+  private initializeSystem(): void {
+    this.registerBuiltInCommands();
+    this.loadLexicon();
+    this.loadLanguagePatterns();
+    this.intentRecognizer.initialize(this.config.patterns as unknown as Record<string, RegExp>);
+    this.commandProcessor.commandRegistry = this.commandRegistry;
+  }
+
+  private registerBuiltInCommands(): void {
+    for (const [command, config] of Object.entries(this.config.commands)) {
+      const handler = command === 'help'
+        ? this.helpCommandHandler.bind(this)
+        : config.handler;
+      this.registerCommand(command, { ...config, handler });
+    }
+  }
+
+  registerCommand(name: string, config: CommandConfig): void {
+    const registered: RegisteredCommand = {
+      name,
+      aliases: config.aliases || [],
+      description: config.description || '',
+      usage: config.usage || '',
+      examples: config.examples || [],
+      handler: config.handler || this.defaultCommandHandler.bind(this),
+      options: config.options || {},
+      validation: config.validation || {},
+    };
+
+    this.commandRegistry.set(name, registered);
+
+    if (config.aliases) {
+      for (const alias of config.aliases) {
+        this.commandRegistry.set(alias, registered);
+      }
+    }
+  }
+
+  private loadLanguagePatterns(): void {
+    this.languagePatterns.set('intent', {
+      question: /^(what|how|when|where|why|who|which)/i,
+      action: /^(create|make|build|generate|start|begin|init|initialize)/i,
+      query: /^(show|display|list|find|search|get|fetch|retrieve)/i,
+      modification: /^(update|modify|edit|change|alter|adjust)/i,
+      deletion: /^(delete|remove|destroy|eliminate|clear|wipe)/i,
+      status: /^(status|info|details|state|condition|health)/i,
+    });
+
+    this.languagePatterns.set('command', {
+      basic: /^[a-z][a-z0-9-]*$/i,
+      compound: /^[a-z][a-z0-9-]*:[a-z][a-z0-9-]*$/i,
+      nested: /^[a-z][a-z0-9-]*:[a-z][a-z0-9-]*:[a-z][a-z0-9-]*$/i,
+    });
+
+    this.languagePatterns.set('option', {
+      short: /^-[a-zA-Z]$/,
+      long: /^--[a-z][a-z0-9-]*$/i,
+      withValue: /^--[a-z][a-z0-9-]*=/i,
+    });
+  }
+
+  private resolveCommand(commandName: string | null): RegisteredCommand | null {
+    if (!commandName) return null;
+    if (this.commandRegistry.has(commandName)) {
+      return this.commandRegistry.get(commandName) ?? null;
+    }
+    const normalized = commandName.startsWith('--') ? commandName.slice(2) : commandName;
+    if (this.commandRegistry.has(normalized)) {
+      return this.commandRegistry.get(normalized) ?? null;
+    }
+    return null;
+  }
+
+  private validateCommand(
+    parsed: ParsedInput,
+    command: RegisteredCommand | null,
+  ): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!command) {
+      errors.push(`Command "${parsed.command ?? ''}" not found`);
+      return { valid: false, errors };
+    }
+
+    const minArgs = command.validation?.minArgs;
+    const maxArgs = command.validation?.maxArgs;
+    if (typeof minArgs === 'number' && parsed.arguments.length < minArgs) {
+      errors.push(`Expected at least ${minArgs} arguments`);
+    }
+    if (typeof maxArgs === 'number' && parsed.arguments.length > maxArgs) {
+      errors.push(`Expected no more than ${maxArgs} arguments`);
+    }
+
+    const allowUnknownOptions =
+      command.validation?.allowUnknownOptions ??
+      this.config.validation?.allowUnknownOptions ??
+      this.validationDefaults.allowUnknownOptions;
+
+    if (!allowUnknownOptions) {
+      for (const optionName of parsed.options.keys()) {
+        if (!command.options?.[optionName]) {
+          errors.push(`Unknown option: ${optionName}`);
+        }
+      }
+    }
+
+    const optionSpecs = command.options ?? {};
+    for (const [optionName, spec] of Object.entries(optionSpecs)) {
+      if (spec.required && !parsed.options.has(optionName)) {
+        errors.push(`Missing required option: ${optionName}`);
+        continue;
+      }
+      if (!parsed.options.has(optionName)) continue;
+      const value = parsed.options.get(optionName);
+      const coerced = this.coerceOptionValue(value, spec);
+      if (!coerced.valid) {
+        errors.push(`Invalid value for option: ${optionName}`);
+        continue;
+      }
+      if (spec.values && coerced.value !== undefined) {
+        const stringValue = String(coerced.value);
+        if (!spec.values.includes(stringValue)) {
+          errors.push(`Invalid value for option: ${optionName}`);
+          continue;
+        }
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  private normalizeOptions(parsed: ParsedInput, command: RegisteredCommand): void {
+    const optionSpecs = command.options ?? {};
+    for (const [name, spec] of Object.entries(optionSpecs)) {
+      if (!parsed.options.has(name) && spec.default !== undefined) {
+        parsed.options.set(name, spec.default);
+      }
+      if (!parsed.options.has(name)) continue;
+      const value = parsed.options.get(name);
+      const coerced = this.coerceOptionValue(value, spec);
+      if (coerced.valid) {
+        parsed.options.set(name, coerced.value);
+      }
+    }
+  }
+
+  private listCommands(): RegisteredCommand[] {
+    const seen = new Set<string>();
+    const commands: RegisteredCommand[] = [];
+    for (const command of this.commandRegistry.values()) {
+      if (seen.has(command.name)) continue;
+      seen.add(command.name);
+      commands.push(command);
+    }
+    return commands.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  private helpCommandHandler(
+    _command: string,
+    options: Map<string, unknown>,
+    args: string[],
+  ): CommandResult {
+    const format = (options.get('format') as string | undefined) ?? 'text';
+    const verbose = Boolean(options.get('verbose'));
+    const target = args[0];
+
+    if (target) {
+      const command = this.resolveCommand(target);
+      if (!command) {
+        return {
+          success: false,
+          error: `Unknown command "${target}"`,
+          suggestions: this.findSimilarCommands(target),
+        };
+      }
+      const payload = {
+        name: command.name,
+        description: command.description,
+        usage: command.usage,
+        aliases: command.aliases,
+        examples: command.examples,
+        options: command.options,
+      };
+      return {
+        success: true,
+        message: this.formatHelpPayload(payload, format, verbose),
+        options,
+        arguments: args,
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    const commands = this.listCommands();
+    const payload = commands.map((command) => ({
+      name: command.name,
+      description: command.description,
+      usage: command.usage,
+      aliases: command.aliases,
+      examples: command.examples,
+      options: command.options,
+    }));
+
+    return {
+      success: true,
+      message: this.formatHelpPayload(payload, format, verbose),
+      options,
+      arguments: args,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  private formatHelpPayload(
+    payload: Record<string, unknown> | Array<Record<string, unknown>>,
+    format: string,
+    verbose: boolean,
+  ): string {
+    if (format === 'json') {
+      return JSON.stringify(payload, null, 2);
+    }
+
+    if (Array.isArray(payload)) {
+      const lines = payload.map((entry) => {
+        const item = entry as { name?: string; description?: string };
+        return `${item.name ?? ''} — ${item.description ?? ''}`.trim();
+      });
+      return lines.join('\n');
+    }
+
+    const entry = payload as {
+      name?: string;
+      description?: string;
+      usage?: string;
+      aliases?: string[];
+      examples?: string[];
+      options?: Record<string, CommandOptionSpec>;
+    };
+
+    const lines: string[] = [];
+    if (entry.name) {
+      lines.push(`${entry.name} — ${entry.description ?? ''}`.trim());
+    }
+    if (entry.usage) {
+      lines.push(`Usage: ${entry.usage}`);
+    }
+    if (verbose && entry.aliases && entry.aliases.length > 0) {
+      lines.push(`Aliases: ${entry.aliases.join(', ')}`);
+    }
+    if (verbose && entry.examples && entry.examples.length > 0) {
+      lines.push(`Examples: ${entry.examples.join(' | ')}`);
+    }
+    if (verbose && entry.options && Object.keys(entry.options).length > 0) {
+      lines.push(`Options: ${Object.keys(entry.options).join(', ')}`);
+    }
+    return lines.join('\n');
+  }
+
+  private coerceOptionValue(
+    value: unknown,
+    spec: CommandOptionSpec,
+  ): { valid: boolean; value: unknown } {
+    if (spec.type === 'boolean') {
+      if (typeof value === 'boolean') return { valid: true, value };
+      if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (['true', '1', 'yes', 'y', 'on'].includes(normalized)) {
+          return { valid: true, value: true };
+        }
+        if (['false', '0', 'no', 'n', 'off'].includes(normalized)) {
+          return { valid: true, value: false };
+        }
+      }
+      if (value === null || value === undefined) {
+        return { valid: true, value: true };
+      }
+      return { valid: false, value };
+    }
+
+    if (spec.type === 'number') {
+      if (typeof value === 'number' && !Number.isNaN(value)) {
+        return { valid: true, value };
+      }
+      if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        if (!Number.isNaN(parsed)) {
+          return { valid: true, value: parsed };
+        }
+      }
+      return { valid: false, value };
+    }
+
+    if (spec.type === 'string') {
+      if (typeof value === 'string') {
+        return { valid: true, value };
+      }
+      if (value === null || value === undefined) {
+        return { valid: false, value };
+      }
+      return { valid: true, value: String(value) };
+    }
+
+    return { valid: true, value };
+  }
+
+  private loadLexicon(): void {
+    const entries = this.config.lexicon ?? {};
+    if (Object.keys(entries).length === 0) {
+      for (const [name, command] of Object.entries(this.config.commands)) {
+        this.lexicon.set(name, {
+          description: command.description || '',
+          aliases: command.aliases ?? [],
+          examples: command.examples ?? [],
+          source: 'built-in',
+        });
+      }
+      return;
+    }
+
+    this.mergeLexicon(entries, 'config');
+  }
+
+  private loadProjectLexicon(projectRoot: string): void {
+    const candidates = [
+      join(projectRoot, '.baseline', 'lang.json'),
+      join(projectRoot, '.baseline', 'lexicon.json'),
+      join(projectRoot, 'baseline.lang.json'),
+    ];
+
+    for (const path of candidates) {
+      if (!existsSync(path)) continue;
+      const raw = readFileSync(path, 'utf8');
+      const parsed = JSON.parse(raw) as unknown;
+      const lexicon = this.extractLexicon(parsed);
+      if (lexicon) {
+        this.mergeLexicon(lexicon, 'project');
+      }
+    }
+  }
+
+  private extractLexicon(input: unknown): Record<string, LexiconEntry> | null {
+    if (!input || typeof input !== 'object') return null;
+    const candidate = input as Record<string, unknown>;
+    const fromContainer = candidate.lexicon;
+    if (fromContainer && typeof fromContainer === 'object') {
+      return this.sanitizeLexicon(fromContainer as Record<string, LexiconEntry>);
+    }
+    return this.sanitizeLexicon(candidate as Record<string, LexiconEntry>);
+  }
+
+  private sanitizeLexicon(entries: Record<string, LexiconEntry>): Record<string, LexiconEntry> {
+    const sanitized: Record<string, LexiconEntry> = {};
+    for (const [term, entry] of Object.entries(entries)) {
+      if (!term.trim()) continue;
+      const description = entry?.description ?? '';
+      sanitized[term.trim()] = {
+        description,
+        aliases: entry?.aliases ?? [],
+        tags: entry?.tags ?? [],
+        examples: entry?.examples ?? [],
+        source: entry?.source,
+      };
+    }
+    return sanitized;
+  }
+
+  public mergeLexicon(entries: Record<string, LexiconEntry>, source?: string): void {
+    for (const [term, entry] of Object.entries(entries)) {
+      const normalized = term.trim();
+      if (!normalized) continue;
+      const existing = this.lexicon.get(normalized);
+      const merged: LexiconEntry = {
+        description: entry.description || existing?.description || '',
+        aliases: this.mergeStringArrays(existing?.aliases, entry.aliases),
+        tags: this.mergeStringArrays(existing?.tags, entry.tags),
+        examples: this.mergeStringArrays(existing?.examples, entry.examples),
+        source: source ?? entry.source ?? existing?.source,
+      };
+      this.lexicon.set(normalized, merged);
+    }
+  }
+
+  private mergeStringArrays(
+    left: string[] | undefined,
+    right: string[] | undefined,
+  ): string[] {
+    const combined = [...(left ?? []), ...(right ?? [])].map((value) => value.trim()).filter(Boolean);
+    return Array.from(new Set(combined));
+  }
+
+  processInput(input: string): ProcessResult {
+    try {
+      const parsed = this.parseInput(input);
+      const intent = this.intentRecognizer.recognize(parsed);
+      const validation = this.syntaxValidator.validate(parsed);
+
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: 'Syntax validation failed',
+          details: validation.errors,
+          suggestions: this.generateSuggestions(input),
+        };
+      }
+
+      const command = this.resolveCommand(parsed.command);
+      const commandValidation = this.validateCommand(parsed, command);
+      if (!commandValidation.valid) {
+        return {
+          success: false,
+          error: 'Command validation failed',
+          details: commandValidation.errors,
+          suggestions: this.generateSuggestions(input),
+        };
+      }
+
+      if (command) {
+        this.normalizeOptions(parsed, command);
+      }
+
+      const result = this.commandProcessor.process(parsed, intent);
+
+      return {
+        success: true,
+        input,
+        parsed,
+        intent,
+        result,
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: 'Processing failed',
+        details: msg,
+        suggestions: this.generateSuggestions(input),
+      };
+    }
+  }
+
+  parseInput(input: string): ParsedInput {
+    const tokens = this.tokenize(input);
+    const parsed: ParsedInput = {
+      original: input,
+      tokens: [...tokens],
+      command: null,
+      options: new Map(),
+      arguments: [],
+      intent: null,
+    };
+
+    if (tokens.length > 0) {
+      const firstToken = tokens[0];
+      if (this.isCommand(firstToken)) {
+        parsed.command = firstToken;
+        tokens.splice(0, 1);
+      }
+    }
+
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+
+      if (this.isOption(token)) {
+        const option = this.parseOption(token);
+        if (option.value) {
+          parsed.options.set(option.name, option.value);
+        } else if (i + 1 < tokens.length && !this.isOption(tokens[i + 1])) {
+          parsed.options.set(option.name, tokens[i + 1]);
+          i++;
+        } else {
+          parsed.options.set(option.name, true);
+        }
+      } else {
+        parsed.arguments.push(token);
+      }
+    }
+
+    return parsed;
+  }
+
+  tokenize(input: string): string[] {
+    const tokens: string[] = [];
+    let current = '';
+    let inQuotes = false;
+    let quoteChar = '';
+
+    for (let i = 0; i < input.length; i++) {
+      const char = input[i];
+
+      if ((char === '"' || char === "'") && !inQuotes) {
+        inQuotes = true;
+        quoteChar = char;
+        continue;
+      }
+
+      if (char === quoteChar && inQuotes) {
+        inQuotes = false;
+        quoteChar = '';
+        if (current.trim()) {
+          tokens.push(current.trim());
+          current = '';
+        }
+        continue;
+      }
+
+      if (char === ' ' && !inQuotes) {
+        if (current.trim()) {
+          tokens.push(current.trim());
+          current = '';
+        }
+        continue;
+      }
+
+      current += char;
+    }
+
+    if (current.trim()) {
+      tokens.push(current.trim());
+    }
+
+    return tokens.filter((token) => token.length > 0);
+  }
+
+  private isCommand(token: string): boolean {
+    if (this.commandRegistry.has(token)) return true;
+    if (this.commandRegistry.has(token.replace(/^--/, ''))) return true;
+    if (/^[a-z][a-z0-9-]*$/i.test(token)) return true;
+    return false;
+  }
+
+  private isOption(token: string): boolean {
+    return token.startsWith('-') || token.startsWith('--');
+  }
+
+  private parseOption(token: string): ParsedOption {
+    if (token.startsWith('--')) {
+      const [name, value] = token.split('=');
+      return { name: name.substring(2), value: value || null, type: 'long' };
+    } else if (token.startsWith('-')) {
+      return { name: token.substring(1), value: null, type: 'short' };
+    }
+    return { name: token, value: null, type: 'unknown' };
+  }
+
+  generateSuggestions(input: string): string[] {
+    const suggestions: string[] = [];
+    const tokens = this.tokenize(input);
+
+    if (tokens.length === 0) {
+      suggestions.push('Try starting with a command like "help" or "create"');
+      return suggestions;
+    }
+
+    const firstToken = tokens[0];
+
+    if (!this.isCommand(firstToken)) {
+      const similarCommands = this.findSimilarCommands(firstToken);
+      if (similarCommands.length > 0) {
+        suggestions.push(`Did you mean: ${similarCommands.join(', ')}?`);
+      }
+    }
+
+    suggestions.push('Use "help" to see available commands');
+    suggestions.push('Use "help <command>" for specific command help');
+
+    return suggestions;
+  }
+
+  private getSuggestionTerms(): string[] {
+    const terms = new Set<string>();
+    for (const key of this.commandRegistry.keys()) {
+      terms.add(key);
+    }
+    for (const [term, entry] of this.lexicon.entries()) {
+      terms.add(term);
+      for (const alias of entry.aliases ?? []) {
+        if (alias.trim()) terms.add(alias.trim());
+      }
+    }
+    return Array.from(terms);
+  }
+
+  findSimilarCommands(input: string, maxResults = 3): string[] {
+    const commands = this.getSuggestionTerms();
+    const similar: string[] = [];
+
+    for (const command of commands) {
+      const distance = this.levenshteinDistance(input.toLowerCase(), command.toLowerCase());
+      if (distance <= 2) {
+        similar.push(command);
+      }
+    }
+
+    return similar.slice(0, maxResults);
+  }
+
+  private levenshteinDistance(str1: string, str2: string): number {
+    const matrix: number[][] = [];
+
+    for (let i = 0; i <= str2.length; i++) {
+      matrix[i] = [i];
+    }
+
+    for (let j = 0; j <= str1.length; j++) {
+      matrix[0][j] = j;
+    }
+
+    for (let i = 1; i <= str2.length; i++) {
+      for (let j = 1; j <= str1.length; j++) {
+        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1,
+          );
+        }
+      }
+    }
+
+    return matrix[str2.length][str1.length];
+  }
+
+  private defaultCommandHandler(
+    command: string,
+    options: Map<string, unknown>,
+    args: string[],
+  ): CommandResult {
+    return {
+      success: true,
+      message: `Command "${command}" executed successfully`,
+      options,
+      arguments: args,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  getCommandRegistry(): Map<string, RegisteredCommand> {
+    return this.commandRegistry;
+  }
+
+  getLanguagePatterns(): Map<string, Record<string, RegExp>> {
+    return this.languagePatterns;
+  }
+
+  getLexicon(): Map<string, LexiconEntry> {
+    return this.lexicon;
+  }
+}