joonecli 0.1.0 → 0.2.0

package/src/commands/commandRegistry.ts

@@ -1,194 +0,0 @@
-/**
- * Slash Command Registry
- *
- * Intercepts user input starting with "/" in the TUI and routes it to
- * registered command handlers. This bypasses the agent loop entirely,
- * making slash commands zero-cost (no LLM tokens consumed).
- *
- * Architecture:
- * - Commands are self-contained objects implementing SlashCommand
- * - The registry supports aliases (e.g., /m → /model)
- * - Unknown commands suggest similar names via Levenshtein distance
- */
-
-import { ContextState } from "../core/promptBuilder.js";
-import { ExecutionHarness } from "../core/agentLoop.js";
-import { JooneConfig } from "../cli/config.js";
-
-// ─── Types ──────────────────────────────────────────────────────────────────────
-
-/**
- * Context passed to every slash command handler.
- * Provides read/write access to session state, config, and UI.
- */
-export interface CommandContext {
-  /** Current Joone configuration. */
-  config: JooneConfig;
-  /** Path to the config file (for commands that modify config). */
-  configPath: string;
-  /** The execution harness (for commands that need LLM access, e.g., /compact). */
-  harness: ExecutionHarness;
-  /** Current conversation/context state. */
-  contextState: ContextState;
-  /** Setter for updating context state from a command. */
-  setContextState: (state: ContextState) => void;
-  /** Setter for pushing UI messages. */
-  addSystemMessage: (content: string) => void;
-  /** Current provider name. */
-  provider: string;
-  /** Current model name. */
-  model: string;
-  /** Max tokens (context window). */
-  maxTokens: number;
-}
-
-/**
- * A registered slash command.
- */
-export interface SlashCommand {
-  /** Primary name (without the leading /). */
-  name: string;
-  /** Optional aliases (e.g., ["m"] for /model). */
-  aliases?: string[];
-  /** Short description shown in /help. */
-  description: string;
-  /** Execute the command. Returns an optional string to display. */
-  execute: (args: string, context: CommandContext) => Promise<string | void>;
-}
-
-// ─── Levenshtein Distance ───────────────────────────────────────────────────────
-
-/**
- * Computes the Levenshtein edit distance between two strings.
- * Used for "did you mean?" suggestions on unknown commands.
- */
-export function levenshteinDistance(a: string, b: string): number {
-  const matrix: number[][] = [];
-
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      const cost = b.charAt(i - 1) === a.charAt(j - 1) ? 0 : 1;
-      matrix[i][j] = Math.min(
-        matrix[i - 1][j] + 1,     // deletion
-        matrix[i][j - 1] + 1,     // insertion
-        matrix[i - 1][j - 1] + cost // substitution
-      );
-    }
-  }
-
-  return matrix[b.length][a.length];
-}
-
-// ─── Registry ───────────────────────────────────────────────────────────────────
-
-export class CommandRegistry {
-  private commands: Map<string, SlashCommand> = new Map();
-  private aliasMap: Map<string, string> = new Map();
-
-  /**
-   * Register a slash command. Overwrites if name already exists.
-   */
-  register(command: SlashCommand): void {
-    this.commands.set(command.name, command);
-
-    if (command.aliases) {
-      for (const alias of command.aliases) {
-        this.aliasMap.set(alias, command.name);
-      }
-    }
-  }
-
-  /**
-   * Returns true if the input looks like a slash command.
-   */
-  isCommand(input: string): boolean {
-    return input.trimStart().startsWith("/");
-  }
-
-  /**
-   * Parse user input into command name and arguments.
-   */
-  private parse(input: string): { name: string; args: string } {
-    const trimmed = input.trimStart().slice(1); // Remove leading "/"
-    const spaceIdx = trimmed.indexOf(" ");
-    if (spaceIdx === -1) {
-      return { name: trimmed.toLowerCase(), args: "" };
-    }
-    return {
-      name: trimmed.slice(0, spaceIdx).toLowerCase(),
-      args: trimmed.slice(spaceIdx + 1).trim(),
-    };
-  }
-
-  /**
-   * Execute a slash command from raw user input.
-   * Returns the command output string, or an error/suggestion message.
-   */
-  async execute(input: string, context: CommandContext): Promise<string> {
-    const { name, args } = this.parse(input);
-
-    // Resolve alias → primary name
-    const resolvedName = this.aliasMap.get(name) ?? name;
-    const command = this.commands.get(resolvedName);
-
-    if (command) {
-      const result = await command.execute(args, context);
-      return result ?? "";
-    }
-
-    // Unknown command — find suggestions
-    const allNames = this.getAllNames();
-    const suggestions = allNames
-      .map((n) => ({ name: n, dist: levenshteinDistance(name, n) }))
-      .filter((s) => s.dist <= 2) // Max 2 edits
-      .sort((a, b) => a.dist - b.dist)
-      .slice(0, 3)
-      .map((s) => `/${s.name}`);
-
-    let msg = `Unknown command: /${name}.`;
-    if (suggestions.length > 0) {
-      msg += ` Did you mean: ${suggestions.join(", ")}?`;
-    }
-    msg += ` Type /help for all commands.`;
-    return msg;
-  }
-
-  /**
-   * Returns all registered commands.
-   */
-  getAll(): SlashCommand[] {
-    return Array.from(this.commands.values());
-  }
-
-  /**
-   * Returns all command names AND aliases (for suggestion matching).
-   */
-  getAllNames(): string[] {
-    const names = Array.from(this.commands.keys());
-    const aliases = Array.from(this.aliasMap.keys());
-    return [...names, ...aliases];
-  }
-
-  /**
-   * Generates formatted help text for all registered commands.
-   */
-  getHelp(): string {
-    const lines: string[] = ["Available commands:\n"];
-
-    for (const cmd of this.commands.values()) {
-      const aliases = cmd.aliases?.length
-        ? ` (${cmd.aliases.map((a) => `/${a}`).join(", ")})`
-        : "";
-      lines.push(`  /${cmd.name}${aliases} — ${cmd.description}`);
-    }
-
-    return lines.join("\n");
-  }
-}

package/src/core/agentLoop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agentLoop.d.ts","sourceRoot":"","sources":["agentLoop.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,SAAS,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,EAA+B,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,qBAAa,gBAAgB;IACzB,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,cAAc,CAAyB;gBAEnC,SAAS,GAAE,MAAqC,EAAE,KAAK,GAAE,oBAAoB,EAAO;IAYhG;;;OAGG;IACU,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC;IAW1D;;OAEG;IACU,gBAAgB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;CAsC9E"}

package/src/core/agentLoop.ts

@@ -1,312 +0,0 @@
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { BaseMessage, AIMessage, ToolMessage, AIMessageChunk, HumanMessage } from "@langchain/core/messages";
-import { Runnable } from "@langchain/core/runnables";
-import { CacheOptimizedPromptBuilder, ContextState } from "./promptBuilder.js";
-import { DynamicToolInterface } from "../tools/index.js";
-import { MiddlewarePipeline } from "../middleware/pipeline.js";
-import { ToolCallContext } from "../middleware/types.js";
-import { SessionTracer } from "../tracing/sessionTracer.js";
-import { countMessageTokens } from "./tokenCounter.js";
-import { SessionStore } from "./sessionStore.js";
-import { retryWithBackoff } from "./retry.js";
-import { wrapLLMError, JooneError, ToolExecutionError } from "./errors.js";
-import { SystemMessage } from "@langchain/core/messages";
-import { ContextGuard } from "./contextGuard.js";
-import { AutoSave } from "./autoSave.js";
-
-export interface StreamStepOptions {
-    /** Called for each text token received from the stream. */
-    onToken?: (token: string) => void;
-}
-
-export class ExecutionHarness {
-    private llm: Runnable<any, AIMessageChunk> | BaseChatModel;
-    private promptBuilder: CacheOptimizedPromptBuilder;
-    private availableTools: DynamicToolInterface[];
-    private pipeline: MiddlewarePipeline;
-    public tracer: SessionTracer;
-    private sessionStore: SessionStore;
-    public sessionId: string;
-    private provider: string;
-    private model: string;
-    private contextGuard: ContextGuard;
-    public autoSave: AutoSave;
-    
-    /**
-     * Initializes the harness with a pre-configured, tool-bound LLM instance.
-     * This allows swapping between Anthropic Claude, OpenAI GPT-4, Google Gemini, etc.
-     */
-    constructor(
-        boundLlm: Runnable<any, AIMessageChunk> | BaseChatModel,
-        tools: DynamicToolInterface[] = [],
-        pipeline?: MiddlewarePipeline,
-        tracer?: SessionTracer,
-        provider: string = "unknown",
-        model: string = "unknown",
-        sessionId?: string,
-        maxTokens: number = 4096
-    ) {
-        this.llm = boundLlm;
-        this.promptBuilder = new CacheOptimizedPromptBuilder();
-        this.availableTools = tools;
-        this.pipeline = pipeline ?? new MiddlewarePipeline();
-        this.tracer = tracer ?? new SessionTracer();
-        this.sessionStore = new SessionStore();
-        this.sessionId = sessionId ?? this.tracer.getSessionId();
-        this.provider = provider;
-        this.model = model;
-        this.contextGuard = new ContextGuard(this.llm, maxTokens, this.promptBuilder);
-        this.autoSave = new AutoSave(this.sessionId, this.sessionStore);
-    }
-
-    /**
-     * The main execution engine (non-streaming).
-     * Takes the context state, builds the cache-optimized prompt, and queries the LLM.
-     */
-    public async step(state: ContextState): Promise<AIMessage> {
-        const start = Date.now();
-        
-        // ContextGuard: Check capacity before building prompt
-        const { state: updatedState, metrics } = await this.contextGuard.ensureCapacity(state);
-        state = updatedState; // Reassign state if compacted
-        
-        const messages = this.promptBuilder.buildPrompt(state);
-
-        try {
-            const response = await retryWithBackoff(
-                () => this.llm.invoke(messages).catch((e) => { throw wrapLLMError(e, this.provider); }),
-                {
-                    onRetry: (attempt, error, delay) => {
-                        this.tracer.recordError({ message: `LLM retry #${attempt}: ${error.message} (waiting ${delay}ms)` });
-                    },
-                }
-            );
-
-            const promptTokens = countMessageTokens(messages);
-            const completionTokens = countMessageTokens([response as AIMessage]);
-
-            this.tracer.recordLLMCall({
-                promptTokens,
-                completionTokens,
-                cached: false,
-                duration: Date.now() - start
-            });
-
-            await this.autoSave.tick({ config: { provider: this.provider, model: this.model }, state });
-            return response as AIMessage;
-        } catch (error: unknown) {
-            // Self-recovery: inject the error hint and let the agent adapt
-            if (error instanceof JooneError && error.retryable) {
-                this.tracer.recordError({ message: `LLM retries exhausted: ${error.message}` });
-                state.conversationHistory.push(new HumanMessage(`<system-alert>\nSystem recovery hint:\n${error.toRecoveryHint()}\n</system-alert>`));
-                await this.autoSave.forceSave({ config: { provider: this.provider, model: this.model }, state });
-                // Return a synthetic AI message so the turn doesn't crash
-                return new AIMessage(error.toRecoveryHint());
-            }
-            throw error; // Fatal (auth, config) — propagate to TUI
-        }
-    }
-
-    /**
-     * Streaming execution engine.
-     * Streams text tokens via the onToken callback and buffers tool call chunks
-     * until the full call is received. Returns a complete AIMessage for history.
-     */
-    public async streamStep(
-        state: ContextState,
-        options: StreamStepOptions
-    ): Promise<AIMessage> {
-        const start = Date.now();
-        
-        // ContextGuard: Check capacity before building prompt
-        const { state: updatedState, metrics } = await this.contextGuard.ensureCapacity(state);
-        state = updatedState;
-        
-        const messages = this.promptBuilder.buildPrompt(state);
-
-        try {
-            const result = await retryWithBackoff(
-                async () => {
-                    let fullContent = "";
-                    const toolCallBuffers: Map<number, { id: string; name: string; argsJson: string }> = new Map();
-
-                    let stream: AsyncIterable<any>;
-                    try {
-                        stream = await (this.llm as any).stream(messages);
-                    } catch (e) {
-                        throw wrapLLMError(e, this.provider);
-                    }
-
-                    for await (const chunk of stream) {
-                        if (chunk.content && typeof chunk.content === "string") {
-                            fullContent += chunk.content;
-                            if (options.onToken) {
-                                options.onToken(chunk.content);
-                            }
-                        }
-
-                        if (chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0) {
-                            for (const tc of chunk.tool_call_chunks) {
-                                const idx = tc.index ?? 0;
-                                if (!toolCallBuffers.has(idx)) {
-                                    toolCallBuffers.set(idx, {
-                                        id: tc.id || "",
-                                        name: tc.name || "",
-                                        argsJson: "",
-                                    });
-                                }
-                                const buf = toolCallBuffers.get(idx)!;
-                                if (tc.id) buf.id = tc.id;
-                                if (tc.name) buf.name = tc.name;
-                                if (tc.args) buf.argsJson += tc.args;
-                            }
-                        }
-                    }
-
-                    const toolCalls = Array.from(toolCallBuffers.values()).map((buf) => ({
-                        id: buf.id,
-                        name: buf.name,
-                        args: (() => {
-                            try {
-                                return JSON.parse(buf.argsJson || "{}");
-                            } catch {
-                                return { _parseError: true, rawArgs: buf.argsJson };
-                            }
-                        })(),
-                        type: "tool_call" as const,
-                    }));
-
-                    return new AIMessage({
-                        content: fullContent,
-                        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-                    });
-                },
-                {
-                    onRetry: (attempt, error, delay) => {
-                        this.tracer.recordError({ message: `LLM stream retry #${attempt}: ${error.message} (waiting ${delay}ms)` });
-                    },
-                }
-            );
-
-            const promptTokens = countMessageTokens(messages);
-            const completionTokens = countMessageTokens([result]);
-
-            this.tracer.recordLLMCall({
-                promptTokens,
-                completionTokens,
-                cached: false,
-                duration: Date.now() - start
-            });
-
-            await this.autoSave.tick({ config: { provider: this.provider, model: this.model }, state });
-            return result;
-        } catch (error: unknown) {
-            // Self-recovery for streaming
-            if (error instanceof JooneError && error.retryable) {
-                this.tracer.recordError({ message: `LLM stream retries exhausted: ${(error as JooneError).message}` });
-                state.conversationHistory.push(new HumanMessage(`<system-alert>\nSystem recovery hint:\n${(error as JooneError).toRecoveryHint()}\n</system-alert>`));
-                await this.autoSave.forceSave({ config: { provider: this.provider, model: this.model }, state });
-                return new AIMessage((error as JooneError).toRecoveryHint());
-            }
-            throw error;
-        }
-    }
-
-    /**
-     * Executes tool calls from an AI response, routing through the middleware pipeline.
-     * Each call passes through all registered before-hooks, then the tool, then after-hooks.
-     */
-    public async executeToolCalls(aiMessage: AIMessage, state: ContextState): Promise<(ToolMessage | HumanMessage)[]> {
-        const results: (ToolMessage | HumanMessage)[] = [];
-        
-        if (!aiMessage.tool_calls || aiMessage.tool_calls.length === 0) {
-            return results;
-        }
-
-        for (const call of aiMessage.tool_calls) {
-            // Soft-Fail Edge Case: If the LLM omits the tool_call_id, do not execute the tool.
-            // Return a HumanMessage prompting correction instead of a malformed ToolMessage.
-            if (!call.id) {
-                this.tracer.recordError({ message: `Malformed tool call: Missing ID for ${call.name}`, tool: call.name });
-                results.push(new HumanMessage(
-                    `You attempted to call the tool '${call.name}', but you did not provide a tool_call_id. ` +
-                    `This is a malformed request. Please try again and ensure you provide a valid ID.`
-                ));
-                continue;
-            }
-
-            const safeCallId = call.id;
-
-            // Handle malformed args from streaming parse errors
-            if (call.args && call.args._parseError) {
-                this.tracer.recordError({ message: `Failed to parse tool arguments`, tool: call.name });
-                results.push(new ToolMessage({
-                    content: `Error: Failed to parse tool arguments. The JSON provided was malformed:\n${call.args.rawArgs}\nPlease correct the JSON format and try again.`,
-                    tool_call_id: safeCallId
-                }));
-                continue;
-            }
-
-            const tool = this.availableTools.find(t => t.name === call.name);
-            if (!tool) {
-                this.tracer.recordError({ message: `Tool ${call.name} not found`, tool: call.name });
-                results.push(new ToolMessage({
-                    content: `Error: Tool ${call.name} not found.`,
-                    tool_call_id: safeCallId
-                }));
-                continue;
-            }
-
-            const ctx: ToolCallContext = {
-                toolName: call.name,
-                args: call.args,
-                callId: safeCallId,
-            };
-
-            const start = Date.now();
-            try {
-                const output = await this.pipeline.run(
-                    ctx,
-                    async (c) => tool.execute(c.args)
-                );
-                this.tracer.recordToolCall({
-                    name: call.name,
-                    args: call.args,
-                    result: typeof output === "string" ? output : JSON.stringify(output).substring(0, 100),
-                    duration: Date.now() - start,
-                    success: true
-                });
-                
-                const stringifiedOutput = typeof output === "string" ? output : JSON.stringify(output);
-                results.push(new ToolMessage({
-                    content: stringifiedOutput,
-                    tool_call_id: safeCallId
-                }));
-            } catch (error: any) {
-                const toolError = new ToolExecutionError(error.message, {
-                    toolName: call.name,
-                    args: call.args,
-                    retryable: false,
-                    cause: error,
-                });
-                this.tracer.recordToolCall({
-                    name: call.name,
-                    args: call.args,
-                    duration: Date.now() - start,
-                    success: false
-                });
-                this.tracer.recordError({ message: toolError.message, tool: call.name });
-                results.push(new ToolMessage({
-                    content: toolError.toRecoveryHint(),
-                    tool_call_id: safeCallId
-                }));
-            }
-        }
-
-        // Add the tool results to the state immediately before saving
-        state.conversationHistory.push(...results);
-        await this.autoSave.tick({ config: { provider: this.provider, model: this.model }, state });
-
-        return results;
-    }
-}

package/src/core/autoSave.ts

@@ -1,95 +0,0 @@
-/**
- * Auto-Save
- *
- * Periodically saves the session state to disk using atomic writes.
- * This prevents data loss if the terminal crashes or the LLM loop hangs.
- * Atomic writes ensure the JSONL session file is never corrupted during save.
- */
-
-import { SessionStore } from "./sessionStore.js";
-import { ContextState } from "./promptBuilder.js";
-import { ActiveToolCall } from "../ui/App.js";
-
-// We extract just what we need for auto-save from the harness
-export interface AutoSaveData {
-  config: { provider: string; model: string };
-  state: ContextState;
-  activeTool?: ActiveToolCall;
-}
-
-export class AutoSave {
-  private store: SessionStore;
-  private sessionId: string;
-  private saveFrequencyTurns: number;
-  private turnsSinceLastSave = 0;
-  private lastSaveTime = 0;
-  private debounceMs: number;
-  private isSaving = false;
-
-  constructor(
-    sessionId: string,
-    store: SessionStore = new SessionStore(),
-    saveFrequencyTurns = 5,
-    debounceMs = 10000 // 10 seconds minimum between saves
-  ) {
-    this.sessionId = sessionId;
-    this.store = store;
-    this.saveFrequencyTurns = saveFrequencyTurns;
-    this.debounceMs = debounceMs;
-  }
-
-  /**
-   * Called at the end of every agent loop turn.
-   * Periodically triggers an atomic save.
-   */
-  async tick(data: AutoSaveData): Promise<boolean> {
-    this.turnsSinceLastSave++;
-
-    const now = Date.now();
-    const shouldSave =
-      this.turnsSinceLastSave >= this.saveFrequencyTurns &&
-      now - this.lastSaveTime >= this.debounceMs;
-
-    if (shouldSave && !this.isSaving) {
-      await this.forceSave(data);
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Forces an immediate atomic save, e.g., during SIGINT/SIGTERM shutdown.
-   */
-  async forceSave(data: AutoSaveData): Promise<void> {
-    if (this.isSaving) return; // Prevent concurrent overlapping saves
-    this.isSaving = true;
-
-    try {
-      // SessionStore.saveSession creates a write stream directly to a new cleanly formatted JSONL payload.
-      await this.store.saveSession(
-        this.sessionId,
-        data.state,
-        data.config.provider,
-        data.config.model
-      );
-
-      this.turnsSinceLastSave = 0;
-      this.lastSaveTime = Date.now();
-    } catch (err: any) {
-      // We explicitly swallow auto-save errors so they don't crash the agent loop.
-      // E2B Sandboxes and other critical operations take precedence.
-      console.error(`\n[AutoSave Failed] ${err.message}`);
-    } finally {
-      this.isSaving = false;
-    }
-  }
-
-  /**
-   * Resets the counter.
-   */
-  resetTimer(): void {
-    this.turnsSinceLastSave = 0;
-    this.lastSaveTime = Date.now();
-  }
-}