@baselineos/lang 0.1.0

package/dist/index.js

@@ -0,0 +1,1082 @@
+// src/system.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// src/config/lang-system-config.json
+var lang_system_config_default = {
+  system: {
+    name: "Baseline Lang System",
+    version: "1.0.0",
+    description: "Natural language processing and command interpretation for Baseline Protocol",
+    language: "en",
+    encoding: "utf-8"
+  },
+  syntax: {
+    commandPrefix: "--",
+    optionPrefix: "-",
+    separator: " ",
+    quoteChar: '"',
+    escapeChar: "\\",
+    wildcard: "*",
+    range: ".."
+  },
+  patterns: {
+    intent: {
+      question: "^(what|how|when|where|why|who|which|can|should|will|do|does|is|are|was|were)",
+      action: "^(create|make|build|generate|start|begin|init|initialize|launch|establish|found|set|put)",
+      query: "^(show|display|list|find|search|get|fetch|retrieve|look|see|view|examine|inspect)",
+      modification: "^(update|modify|edit|change|alter|adjust|transform|convert|adapt|revise|amend)",
+      deletion: "^(delete|remove|destroy|eliminate|clear|wipe|erase|purge|drop|uninstall)",
+      status: "^(status|info|details|state|condition|health|check|verify|validate|test)",
+      navigation: "^(go|navigate|move|jump|switch|change|enter|exit|open|close)",
+      configuration: "^(config|configure|setup|install|deploy|arrange|organize|structure)"
+    },
+    command: {
+      basic: "^[a-z][a-z0-9-]*$",
+      compound: "^[a-z][a-z0-9-]*:[a-z][a-z0-9-]*$",
+      nested: "^[a-z][a-z0-9-]*:[a-z][a-z0-9-]*:[a-z][a-z0-9-]*$",
+      namespaced: "^[a-z][a-z0-9-]*\\.[a-z][a-z0-9-]*$"
+    },
+    option: {
+      short: "^-[a-zA-Z]$",
+      long: "^--[a-z][a-z0-9-]*$",
+      withValue: "^--[a-z][a-z0-9-]*=",
+      flag: "^--[a-z][a-z0-9-]*$"
+    },
+    value: {
+      text: "^[a-zA-Z0-9\\s\\-_\\.,/\\\\]+$",
+      number: "^[0-9]+(\\.[0-9]+)?$",
+      identifier: "^[a-zA-Z_][a-zA-Z0-9_]*$",
+      path: "^[a-zA-Z0-9\\-_/\\\\\\.]+$",
+      url: "^https?://[a-zA-Z0-9\\-_./]+$",
+      email: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
+    }
+  },
+  commands: {
+    help: {
+      aliases: ["h", "?", "--help", "help"],
+      description: "Show help information and command reference",
+      usage: "help [command] [options]",
+      examples: [
+        "help",
+        "help create",
+        "help --verbose",
+        "help create project"
+      ],
+      options: {
+        verbose: {
+          type: "boolean",
+          description: "Show detailed help information",
+          default: false
+        },
+        format: {
+          type: "string",
+          description: "Output format (text, json, markdown)",
+          default: "text",
+          values: ["text", "json", "markdown"]
+        }
+      }
+    },
+    create: {
+      aliases: ["c", "new", "make", "build", "generate"],
+      description: "Create a new resource or entity",
+      usage: "create <type> [name] [options]",
+      examples: [
+        "create project",
+        "create project myproject",
+        'create --type=project --name=myproject --description="A new project"',
+        "create project myproject --template=web --framework=react"
+      ],
+      options: {
+        type: {
+          type: "string",
+          description: "Type of resource to create",
+          required: true,
+          values: ["project", "service", "component", "document", "user", "team"]
+        },
+        name: {
+          type: "string",
+          description: "Name of the resource",
+          required: false
+        },
+        description: {
+          type: "string",
+          description: "Description of the resource",
+          required: false
+        },
+        template: {
+          type: "string",
+          description: "Template to use for creation",
+          required: false
+        },
+        framework: {
+          type: "string",
+          description: "Framework to use",
+          required: false
+        },
+        force: {
+          type: "boolean",
+          description: "Force creation even if resource exists",
+          default: false
+        }
+      }
+    },
+    list: {
+      aliases: ["ls", "show", "display", "view"],
+      description: "List resources or entities",
+      usage: "list [type] [options]",
+      examples: [
+        "list",
+        "list projects",
+        "list --type=project --format=json",
+        "list projects --filter=active --sort=name"
+      ],
+      options: {
+        type: {
+          type: "string",
+          description: "Type of resources to list",
+          required: false
+        },
+        format: {
+          type: "string",
+          description: "Output format (text, json, table, csv)",
+          default: "text",
+          values: ["text", "json", "table", "csv"]
+        },
+        filter: {
+          type: "string",
+          description: "Filter criteria",
+          required: false
+        },
+        sort: {
+          type: "string",
+          description: "Sort field",
+          required: false
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results",
+          default: 50
+        }
+      }
+    },
+    update: {
+      aliases: ["u", "modify", "edit", "change", "alter"],
+      description: "Update an existing resource or entity",
+      usage: "update <type> <id> [options]",
+      examples: [
+        "update project 123",
+        "update project 123 --name=newName",
+        'update --type=project --id=123 --description="Updated description"'
+      ],
+      options: {
+        type: {
+          type: "string",
+          description: "Type of resource to update",
+          required: true
+        },
+        id: {
+          type: "string",
+          description: "ID of the resource",
+          required: true
+        },
+        name: {
+          type: "string",
+          description: "New name for the resource",
+          required: false
+        },
+        description: {
+          type: "string",
+          description: "New description for the resource",
+          required: false
+        },
+        force: {
+          type: "boolean",
+          description: "Force update even if validation fails",
+          default: false
+        }
+      }
+    },
+    delete: {
+      aliases: ["d", "remove", "rm", "del", "destroy"],
+      description: "Delete a resource or entity",
+      usage: "delete <type> <id> [options]",
+      examples: [
+        "delete project 123",
+        "delete project 123 --force",
+        "delete --type=project --id=123 --confirm"
+      ],
+      options: {
+        type: {
+          type: "string",
+          description: "Type of resource to delete",
+          required: true
+        },
+        id: {
+          type: "string",
+          description: "ID of the resource",
+          required: true
+        },
+        force: {
+          type: "boolean",
+          description: "Force deletion without confirmation",
+          default: false
+        },
+        confirm: {
+          type: "boolean",
+          description: "Confirm deletion",
+          default: false
+        }
+      }
+    },
+    status: {
+      aliases: ["s", "info", "details", "health"],
+      description: "Show status information about resources or system",
+      usage: "status [type] [id] [options]",
+      examples: [
+        "status",
+        "status project 123",
+        "status system",
+        "status --type=project --id=123 --verbose"
+      ],
+      options: {
+        type: {
+          type: "string",
+          description: "Type of resource to check status",
+          required: false
+        },
+        id: {
+          type: "string",
+          description: "ID of the resource",
+          required: false
+        },
+        verbose: {
+          type: "boolean",
+          description: "Show detailed status information",
+          default: false
+        },
+        format: {
+          type: "string",
+          description: "Output format (text, json, table)",
+          default: "text",
+          values: ["text", "json", "table"]
+        }
+      }
+    },
+    config: {
+      aliases: ["cfg", "settings", "configure"],
+      description: "Manage system configuration and settings",
+      usage: "config [action] [key] [value] [options]",
+      examples: [
+        "config show",
+        "config get database.url",
+        "config set database.url localhost:5432",
+        "config list --format=json"
+      ],
+      options: {
+        action: {
+          type: "string",
+          description: "Action to perform (show, get, set, list, reset)",
+          required: false,
+          values: ["show", "get", "set", "list", "reset", "export", "import"]
+        },
+        key: {
+          type: "string",
+          description: "Configuration key",
+          required: false
+        },
+        value: {
+          type: "string",
+          description: "Configuration value",
+          required: false
+        },
+        format: {
+          type: "string",
+          description: "Output format (text, json, yaml)",
+          default: "text",
+          values: ["text", "json", "yaml"]
+        }
+      }
+    },
+    test: {
+      aliases: ["t", "validate", "check", "verify"],
+      description: "Run tests or validation checks",
+      usage: "test [type] [options]",
+      examples: [
+        "test",
+        "test unit",
+        "test integration --verbose",
+        "test --type=system --format=json"
+      ],
+      options: {
+        type: {
+          type: "string",
+          description: "Type of tests to run",
+          required: false,
+          values: ["unit", "integration", "system", "all"]
+        },
+        verbose: {
+          type: "boolean",
+          description: "Show detailed test output",
+          default: false
+        },
+        format: {
+          type: "string",
+          description: "Output format (text, json, junit)",
+          default: "text",
+          values: ["text", "json", "junit"]
+        }
+      }
+    }
+  },
+  validation: {
+    strict: false,
+    allowUnknown: true,
+    maxTokens: 100,
+    maxOptions: 20,
+    maxArguments: 10
+  },
+  errorHandling: {
+    suggestions: true,
+    fuzzyMatching: true,
+    maxSuggestions: 5,
+    levenshteinThreshold: 2
+  },
+  performance: {
+    cacheSize: 1e3,
+    maxCacheAge: 3e5,
+    enableProfiling: false,
+    logPerformance: false
+  }
+};
+
+// src/system.ts
+var IntentRecognizer = class {
+  patterns = /* @__PURE__ */ new Map();
+  initialize(patterns) {
+    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);
+      }
+    }
+  }
+  recognize(parsed) {
+    const intent = {
+      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;
+  }
+  analyzeCommand(command) {
+    const patterns = this.patterns.get("intent") || {};
+    let bestMatch = { 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;
+  }
+  analyzeArguments(args) {
+    const patterns = this.patterns.get("intent") || {};
+    let bestMatch = { 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;
+  }
+};
+var CommandProcessor = class {
+  commandRegistry = null;
+  process(parsed, _intent) {
+    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}`
+      };
+    }
+  }
+  findCommand(commandName) {
+    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;
+  }
+};
+var SyntaxValidator = class {
+  validate(parsed) {
+    const errors = [];
+    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 };
+  }
+  isValidOption(option) {
+    return /^[a-z][a-z0-9-]*$/i.test(option);
+  }
+};
+var BaselineLangSystem = class {
+  config;
+  commandRegistry = /* @__PURE__ */ new Map();
+  languagePatterns = /* @__PURE__ */ new Map();
+  intentRecognizer = new IntentRecognizer();
+  commandProcessor = new CommandProcessor();
+  syntaxValidator = new SyntaxValidator();
+  lexicon = /* @__PURE__ */ new Map();
+  validationDefaults = {
+    allowUnknownOptions: true
+  };
+  constructor(options = {}) {
+    this.config = this.loadConfiguration();
+    this.initializeSystem();
+    if (options.projectLexicon) {
+      this.mergeLexicon(options.projectLexicon, "project");
+    }
+    if (options.projectRoot) {
+      this.loadProjectLexicon(options.projectRoot);
+    }
+  }
+  loadConfiguration() {
+    const cfg = lang_system_config_default;
+    const syntaxCfg = cfg.syntax ?? {};
+    const patternsCfg = cfg.patterns ?? {};
+    const commandsCfg = cfg.commands ?? {};
+    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 ?? "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
+      }
+    };
+  }
+  initializeSystem() {
+    this.registerBuiltInCommands();
+    this.loadLexicon();
+    this.loadLanguagePatterns();
+    this.intentRecognizer.initialize(this.config.patterns);
+    this.commandProcessor.commandRegistry = this.commandRegistry;
+  }
+  registerBuiltInCommands() {
+    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, config) {
+    const registered = {
+      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);
+      }
+    }
+  }
+  loadLanguagePatterns() {
+    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
+    });
+  }
+  resolveCommand(commandName) {
+    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;
+  }
+  validateCommand(parsed, command) {
+    const errors = [];
+    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 !== void 0) {
+        const stringValue = String(coerced.value);
+        if (!spec.values.includes(stringValue)) {
+          errors.push(`Invalid value for option: ${optionName}`);
+          continue;
+        }
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  normalizeOptions(parsed, command) {
+    const optionSpecs = command.options ?? {};
+    for (const [name, spec] of Object.entries(optionSpecs)) {
+      if (!parsed.options.has(name) && spec.default !== void 0) {
+        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);
+      }
+    }
+  }
+  listCommands() {
+    const seen = /* @__PURE__ */ new Set();
+    const commands = [];
+    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));
+  }
+  helpCommandHandler(_command, options, args) {
+    const format = options.get("format") ?? "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 payload2 = {
+        name: command.name,
+        description: command.description,
+        usage: command.usage,
+        aliases: command.aliases,
+        examples: command.examples,
+        options: command.options
+      };
+      return {
+        success: true,
+        message: this.formatHelpPayload(payload2, format, verbose),
+        options,
+        arguments: args,
+        timestamp: (/* @__PURE__ */ 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: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  formatHelpPayload(payload, format, verbose) {
+    if (format === "json") {
+      return JSON.stringify(payload, null, 2);
+    }
+    if (Array.isArray(payload)) {
+      const lines2 = payload.map((entry2) => {
+        const item = entry2;
+        return `${item.name ?? ""} \u2014 ${item.description ?? ""}`.trim();
+      });
+      return lines2.join("\n");
+    }
+    const entry = payload;
+    const lines = [];
+    if (entry.name) {
+      lines.push(`${entry.name} \u2014 ${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");
+  }
+  coerceOptionValue(value, spec) {
+    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 === void 0) {
+        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 === void 0) {
+        return { valid: false, value };
+      }
+      return { valid: true, value: String(value) };
+    }
+    return { valid: true, value };
+  }
+  loadLexicon() {
+    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");
+  }
+  loadProjectLexicon(projectRoot) {
+    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);
+      const lexicon = this.extractLexicon(parsed);
+      if (lexicon) {
+        this.mergeLexicon(lexicon, "project");
+      }
+    }
+  }
+  extractLexicon(input) {
+    if (!input || typeof input !== "object") return null;
+    const candidate = input;
+    const fromContainer = candidate.lexicon;
+    if (fromContainer && typeof fromContainer === "object") {
+      return this.sanitizeLexicon(fromContainer);
+    }
+    return this.sanitizeLexicon(candidate);
+  }
+  sanitizeLexicon(entries) {
+    const sanitized = {};
+    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;
+  }
+  mergeLexicon(entries, source) {
+    for (const [term, entry] of Object.entries(entries)) {
+      const normalized = term.trim();
+      if (!normalized) continue;
+      const existing = this.lexicon.get(normalized);
+      const merged = {
+        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);
+    }
+  }
+  mergeStringArrays(left, right) {
+    const combined = [...left ?? [], ...right ?? []].map((value) => value.trim()).filter(Boolean);
+    return Array.from(new Set(combined));
+  }
+  processInput(input) {
+    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: (/* @__PURE__ */ 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) {
+    const tokens = this.tokenize(input);
+    const parsed = {
+      original: input,
+      tokens: [...tokens],
+      command: null,
+      options: /* @__PURE__ */ 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) {
+    const tokens = [];
+    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);
+  }
+  isCommand(token) {
+    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;
+  }
+  isOption(token) {
+    return token.startsWith("-") || token.startsWith("--");
+  }
+  parseOption(token) {
+    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) {
+    const suggestions = [];
+    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;
+  }
+  getSuggestionTerms() {
+    const terms = /* @__PURE__ */ new Set();
+    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, maxResults = 3) {
+    const commands = this.getSuggestionTerms();
+    const similar = [];
+    for (const command of commands) {
+      const distance = this.levenshteinDistance(input.toLowerCase(), command.toLowerCase());
+      if (distance <= 2) {
+        similar.push(command);
+      }
+    }
+    return similar.slice(0, maxResults);
+  }
+  levenshteinDistance(str1, str2) {
+    const matrix = [];
+    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];
+  }
+  defaultCommandHandler(command, options, args) {
+    return {
+      success: true,
+      message: `Command "${command}" executed successfully`,
+      options,
+      arguments: args,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  getCommandRegistry() {
+    return this.commandRegistry;
+  }
+  getLanguagePatterns() {
+    return this.languagePatterns;
+  }
+  getLexicon() {
+    return this.lexicon;
+  }
+};
+export {
+  BaselineLangSystem,
+  CommandProcessor,
+  IntentRecognizer,
+  SyntaxValidator
+};
+/**
+ * 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
+ */