@baselineos/lang 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,14 @@
+
+> @baselineos/lang@0.1.0 build /home/runner/work/baseline/baseline/packages/lang
+> tsup src/index.ts --format esm --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2022
+ESM Build start
+ESM dist/index.js 33.32 KB
+ESM ⚡️ Build success in 216ms
+DTS Build start
+DTS ⚡️ Build success in 14890ms
+DTS dist/index.d.ts 5.14 KB

package/.turbo/turbo-test.log

@@ -0,0 +1,16 @@
+
+> @baselineos/lang@0.1.0 test /home/runner/work/baseline/baseline/packages/lang
+> vitest run
+
+
+ RUN  v2.1.9 /home/runner/work/baseline/baseline/packages/lang
+
+ ✓ src/__tests__/validation.test.ts (5 tests) 184ms
+ ✓ src/__tests__/smoke.test.ts (2 tests) 28ms
+ ✓ src/__tests__/workflow.test.ts (1 test) 82ms
+
+ Test Files  3 passed (3)
+      Tests  8 passed (8)
+   Start at  14:02:30
+   Duration  6.28s (transform 1.37s, setup 0ms, collect 1.60s, tests 295ms, environment 1ms, prepare 1.81s)
+

package/LICENSE

@@ -0,0 +1,17 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright 2026 Baseline Protocol Foundation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,19 @@
+# @baselineos/lang
+
+Lang layer package for Baseline.
+
+## Purpose
+
+Implements language parsing/normalization and baseline terminology handling for workflow input interpretation.
+
+## Commands
+
+```bash
+pnpm --filter @baselineos/lang build
+pnpm --filter @baselineos/lang test
+```
+
+## Integration
+
+- Depends on: `@baselineos/protocol-core`
+- Consumed by: `@baselineos/cli`, `baselineos`

package/dist/index.d.ts

@@ -0,0 +1,176 @@
+/**
+ * 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
+ */
+interface LangSystemConfig {
+    language: string;
+    syntax: SyntaxConfig;
+    patterns: PatternConfig;
+    commands: Record<string, CommandConfig>;
+    lexicon?: Record<string, LexiconEntry>;
+    validation?: LangValidationConfig;
+}
+interface SyntaxConfig {
+    commandPrefix: string;
+    optionPrefix: string;
+    separator: string;
+    quoteChar: string;
+}
+interface PatternConfig {
+    intent: RegExp;
+    command: RegExp;
+    option: RegExp;
+    value: RegExp;
+}
+interface LangValidationConfig {
+    allowUnknownOptions?: boolean;
+}
+interface CommandOptionSpec {
+    type?: 'string' | 'number' | 'boolean';
+    description?: string;
+    required?: boolean;
+    default?: unknown;
+    values?: string[];
+}
+interface CommandValidationSpec {
+    minArgs?: number;
+    maxArgs?: number;
+    allowUnknownOptions?: boolean;
+}
+interface LexiconEntry {
+    description: string;
+    aliases?: string[];
+    tags?: string[];
+    examples?: string[];
+    source?: string;
+}
+interface CommandConfig {
+    aliases: string[];
+    description: string;
+    usage: string;
+    examples: string[];
+    handler?: CommandHandler;
+    options?: Record<string, CommandOptionSpec>;
+    validation?: CommandValidationSpec;
+}
+interface RegisteredCommand {
+    name: string;
+    aliases: string[];
+    description: string;
+    usage: string;
+    examples: string[];
+    handler: CommandHandler;
+    options: Record<string, CommandOptionSpec>;
+    validation: CommandValidationSpec;
+}
+type CommandHandler = (command: string, options: Map<string, unknown>, args: string[]) => CommandResult;
+interface CommandResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+    options?: Map<string, unknown>;
+    arguments?: string[];
+    suggestions?: string[];
+    timestamp?: string;
+}
+interface ParsedInput {
+    original: string;
+    tokens: string[];
+    command: string | null;
+    options: Map<string, unknown>;
+    arguments: string[];
+    intent: string | null;
+}
+interface IntentResult {
+    type: string;
+    confidence: number;
+    patterns: RegExp[];
+}
+interface ProcessResult {
+    success: boolean;
+    input?: string;
+    parsed?: ParsedInput;
+    intent?: IntentResult;
+    result?: CommandResult;
+    error?: string;
+    details?: string | string[];
+    suggestions?: string[];
+    timestamp?: string;
+}
+interface ParsedOption {
+    name: string;
+    value: string | null;
+    type: 'long' | 'short' | 'unknown';
+}
+interface BaselineLangOptions {
+    projectRoot?: string;
+    projectLexicon?: Record<string, LexiconEntry>;
+}
+declare class IntentRecognizer {
+    private patterns;
+    initialize(patterns: Record<string, unknown>): void;
+    recognize(parsed: ParsedInput): IntentResult;
+    private analyzeCommand;
+    private analyzeArguments;
+}
+declare class CommandProcessor {
+    commandRegistry: Map<string, RegisteredCommand> | null;
+    process(parsed: ParsedInput, _intent: IntentResult): CommandResult;
+    private findCommand;
+}
+declare class SyntaxValidator {
+    validate(parsed: ParsedInput): {
+        valid: boolean;
+        errors: string[];
+    };
+    private isValidOption;
+}
+declare class BaselineLangSystem {
+    private config;
+    private commandRegistry;
+    private languagePatterns;
+    private intentRecognizer;
+    private commandProcessor;
+    private syntaxValidator;
+    private lexicon;
+    private validationDefaults;
+    constructor(options?: BaselineLangOptions);
+    private loadConfiguration;
+    private initializeSystem;
+    private registerBuiltInCommands;
+    registerCommand(name: string, config: CommandConfig): void;
+    private loadLanguagePatterns;
+    private resolveCommand;
+    private validateCommand;
+    private normalizeOptions;
+    private listCommands;
+    private helpCommandHandler;
+    private formatHelpPayload;
+    private coerceOptionValue;
+    private loadLexicon;
+    private loadProjectLexicon;
+    private extractLexicon;
+    private sanitizeLexicon;
+    mergeLexicon(entries: Record<string, LexiconEntry>, source?: string): void;
+    private mergeStringArrays;
+    processInput(input: string): ProcessResult;
+    parseInput(input: string): ParsedInput;
+    tokenize(input: string): string[];
+    private isCommand;
+    private isOption;
+    private parseOption;
+    generateSuggestions(input: string): string[];
+    private getSuggestionTerms;
+    findSimilarCommands(input: string, maxResults?: number): string[];
+    private levenshteinDistance;
+    private defaultCommandHandler;
+    getCommandRegistry(): Map<string, RegisteredCommand>;
+    getLanguagePatterns(): Map<string, Record<string, RegExp>>;
+    getLexicon(): Map<string, LexiconEntry>;
+}
+
+export { type BaselineLangOptions, BaselineLangSystem, type CommandConfig, type CommandHandler, type CommandOptionSpec, CommandProcessor, type CommandResult, type CommandValidationSpec, IntentRecognizer, type IntentResult, type LangSystemConfig, type LangValidationConfig, type LexiconEntry, type ParsedInput, type ParsedOption, type PatternConfig, type ProcessResult, type RegisteredCommand, type SyntaxConfig, SyntaxValidator };