@zhijiewang/openharness 2.4.0 → 2.8.0

package/dist/commands/session.js

@@ -0,0 +1,214 @@
+/**
+ * Session commands — /clear, /compact, /export, /history, /browse, /resume, /fork, /pin, /unpin
+ */
+import { existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { getContextWindow } from "../harness/cost.js";
+import { createSession, listSessions, loadSession, saveSession } from "../harness/session.js";
+import { compressMessages } from "../query/index.js";
+function setPinned(args, ctx, pinned) {
+    const idx = parseInt(args.trim(), 10);
+    if (Number.isNaN(idx) || idx < 1 || idx > ctx.messages.length) {
+        return { output: `Usage: /${pinned ? "pin" : "unpin"} <message-number> (1-${ctx.messages.length})`, handled: true };
+    }
+    const updatedMessages = ctx.messages.map((m, i) => (i === idx - 1 ? { ...m, meta: { ...m.meta, pinned } } : m));
+    return {
+        output: `Message #${idx} ${pinned ? "pinned" : "unpinned"}.`,
+        handled: true,
+        compactedMessages: updatedMessages,
+    };
+}
+export function registerSessionCommands(register) {
+    register("clear", "Clear conversation history", () => {
+        return { output: "Conversation cleared.", handled: true, clearMessages: true };
+    });
+    register("compact", "Compress conversation history (optional: focus keyword or message number)", (args, ctx) => {
+        const focus = args.trim();
+        const before = ctx.messages.length;
+        const targetTokens = Math.floor(getContextWindow(ctx.model) * 0.6);
+        if (focus && /^\d+$/.test(focus)) {
+            const cutoff = parseInt(focus, 10);
+            if (cutoff < 1 || cutoff >= before) {
+                return { output: `Invalid: use 1-${before - 1}`, handled: true };
+            }
+            const kept = ctx.messages.slice(cutoff);
+            return {
+                output: `Compacted: removed first ${cutoff} messages, kept ${kept.length}.`,
+                handled: true,
+                compactedMessages: kept,
+            };
+        }
+        if (focus) {
+            const focusLower = focus.toLowerCase();
+            const preserved = ctx.messages.filter((m) => m.content.toLowerCase().includes(focusLower) || m.meta?.pinned);
+            const others = ctx.messages.filter((m) => !m.content.toLowerCase().includes(focusLower) && !m.meta?.pinned);
+            const compactedOthers = compressMessages(others, targetTokens);
+            const merged = [...compactedOthers, ...preserved].sort((a, b) => a.timestamp - b.timestamp);
+            return {
+                output: `Compacted with focus "${focus}": ${before} → ${merged.length} messages (preserved ${preserved.length} matching).`,
+                handled: true,
+                compactedMessages: merged,
+            };
+        }
+        const compacted = compressMessages(ctx.messages, targetTokens);
+        const dropped = before - compacted.length;
+        return {
+            output: `Compacted: ${before} → ${compacted.length} messages (dropped ${dropped} older turns).`,
+            handled: true,
+            compactedMessages: compacted,
+        };
+    });
+    register("export", "Export conversation to file", (_args, ctx) => {
+        const lines = ctx.messages
+            .filter((m) => m.role === "user" || m.role === "assistant")
+            .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`)
+            .join("\n\n");
+        const filename = `.oh/export-${ctx.sessionId}.md`;
+        try {
+            mkdirSync(dirname(filename), { recursive: true });
+            const { writeFileSync } = require("node:fs");
+            writeFileSync(filename, lines);
+            return { output: `Exported to ${filename}`, handled: true };
+        }
+        catch {
+            return { output: `Export failed. Content:\n\n${lines.slice(0, 500)}`, handled: true };
+        }
+    });
+    register("history", "List recent sessions or search across them", (args) => {
+        const parts = args.trim().split(/\s+/);
+        const sessionDir = join(homedir(), ".oh", "sessions");
+        if (parts[0] === "search" && parts[1]) {
+            const term = parts.slice(1).join(" ").toLowerCase();
+            const sessions = listSessions(sessionDir);
+            const matches = [];
+            for (const s of sessions) {
+                try {
+                    const full = loadSession(s.id, sessionDir);
+                    const hit = full.messages.find((m) => typeof m.content === "string" && m.content.toLowerCase().includes(term));
+                    if (hit) {
+                        const date = new Date(s.updatedAt).toLocaleDateString();
+                        matches.push(`  ${s.id}  ${date}  ${s.model || "?"}`);
+                    }
+                }
+                catch {
+                    /* skip */
+                }
+            }
+            if (matches.length === 0)
+                return { output: `No sessions matching "${term}".`, handled: true };
+            return { output: `Sessions matching "${term}":\n${matches.join("\n")}`, handled: true };
+        }
+        const n = parseInt(parts[0] ?? "10", 10) || 10;
+        const sessions = listSessions(sessionDir).slice(0, n);
+        if (sessions.length === 0)
+            return { output: "No saved sessions.", handled: true };
+        const lines = sessions.map((s) => {
+            const date = new Date(s.updatedAt).toLocaleDateString();
+            const cost = s.cost > 0 ? ` $${s.cost.toFixed(4)}` : "";
+            return `  ${s.id}  ${date}  ${String(s.messages).padStart(3)} msgs  ${(s.model || "?").slice(0, 24)}${cost}`;
+        });
+        return { output: `Recent sessions (use /resume <id> to continue):\n${lines.join("\n")}`, handled: true };
+    });
+    register("browse", "Open interactive session browser", () => {
+        return { output: "__OPEN_SESSION_BROWSER__", handled: true };
+    });
+    register("resume", "Resume a saved session by ID", (args) => {
+        const id = args.trim();
+        if (!id)
+            return { output: "Usage: /resume <session-id>", handled: true };
+        const sessionDir = join(homedir(), ".oh", "sessions");
+        try {
+            loadSession(id, sessionDir);
+            return { output: `Resuming session ${id}...`, handled: true, resumeSessionId: id };
+        }
+        catch {
+            return { output: `Session not found: ${id}`, handled: true };
+        }
+    });
+    register("fork", "Fork current session (create a branch you can resume later)", (_args, ctx) => {
+        const forked = createSession("", "");
+        forked.messages = [...ctx.messages];
+        saveSession(forked);
+        return {
+            output: `Session forked as ${forked.id}. Resume later with: oh --resume ${forked.id}`,
+            handled: true,
+        };
+    });
+    register("pin", "Pin a message (survives /compact)", (args, ctx) => setPinned(args, ctx, true));
+    register("unpin", "Unpin a message", (args, ctx) => setPinned(args, ctx, false));
+    register("rebuild-sessions", "Rebuild session search index", () => {
+        import("../harness/session-db.js")
+            .then(({ openSessionDb, rebuildIndex, closeSessionDb }) => {
+            const db = openSessionDb();
+            const count = rebuildIndex(db);
+            closeSessionDb(db);
+            console.log(`Rebuilt session search index: ${count} sessions indexed.`);
+        })
+            .catch((err) => {
+            console.log(`Failed to rebuild index: ${err.message}`);
+        });
+        return { output: "Rebuilding session search index...", handled: true };
+    });
+    register("add-dir", "Add an additional working directory", (args) => {
+        const dir = args.trim();
+        if (!dir) {
+            return {
+                output: "Usage: /add-dir <path>\n\nAdds a directory to the session's working directories, allowing the AI to access files in multiple locations.",
+                handled: true,
+            };
+        }
+        const resolved = resolve(dir);
+        if (!existsSync(resolved)) {
+            return { output: `Directory not found: ${resolved}`, handled: true };
+        }
+        return { output: `Added working directory: ${resolved}`, handled: true };
+    });
+    register("listen", "Listen to stdin for input", () => {
+        return {
+            output: "Listening mode enabled. Paste or pipe input, then press Ctrl+D (EOF) to submit.",
+            handled: true,
+        };
+    });
+    register("truncate", "Remove messages from the end of conversation", (args, ctx) => {
+        const countStr = args.trim();
+        const count = parseInt(countStr, 10);
+        if (!countStr || Number.isNaN(count) || count < 1) {
+            return {
+                output: `Usage: /truncate <count>\n\nRemove the last <count> messages from the conversation.\nCurrent message count: ${ctx.messages.length}`,
+                handled: true,
+            };
+        }
+        if (count >= ctx.messages.length) {
+            return { output: "Cannot truncate all messages. Use /clear instead.", handled: true };
+        }
+        const kept = ctx.messages.slice(0, ctx.messages.length - count);
+        return {
+            output: `Truncated ${count} message(s). ${kept.length} remaining.`,
+            handled: true,
+            compactedMessages: kept,
+        };
+    });
+    register("search", "Search current conversation", (args, ctx) => {
+        const term = args.trim().toLowerCase();
+        if (!term) {
+            return {
+                output: "Usage: /search <term>\n\nSearch through all messages in the current conversation.",
+                handled: true,
+            };
+        }
+        const matches = [];
+        for (let i = 0; i < ctx.messages.length; i++) {
+            const msg = ctx.messages[i];
+            if (typeof msg.content === "string" && msg.content.toLowerCase().includes(term)) {
+                const preview = msg.content.slice(0, 80).replace(/\n/g, " ");
+                matches.push(`  #${i + 1} [${msg.role}]: ${preview}...`);
+            }
+        }
+        if (matches.length === 0) {
+            return { output: `No messages matching "${term}".`, handled: true };
+        }
+        return { output: `Found ${matches.length} message(s) matching "${term}":\n${matches.join("\n")}`, handled: true };
+    });
+}
+//# sourceMappingURL=session.js.map

package/dist/commands/settings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Settings commands — /theme, /companion, /fast, /keys, /effort, /sandbox, /permissions, /allowed-tools
+ */
+import type { CommandHandler } from "./types.js";
+export declare function registerSettingsCommands(register: (name: string, description: string, handler: CommandHandler) => void): void;
+//# sourceMappingURL=settings.d.ts.map

package/dist/commands/settings.js

@@ -0,0 +1,187 @@
+/**
+ * Settings commands — /theme, /companion, /fast, /keys, /effort, /sandbox, /permissions, /allowed-tools
+ */
+import { readOhConfig } from "../harness/config.js";
+import { loadKeybindings } from "../harness/keybindings.js";
+export function registerSettingsCommands(register) {
+    register("theme", "Switch theme (dark/light)", (args) => {
+        const theme = args.trim().toLowerCase();
+        if (theme !== "dark" && theme !== "light") {
+            return { output: "Usage: /theme dark or /theme light", handled: true };
+        }
+        return { output: `__SWITCH_THEME__:${theme}`, handled: true };
+    });
+    register("companion", "Toggle companion visibility (off/on)", (args) => {
+        const arg = args.trim().toLowerCase();
+        if (arg === "off")
+            return { output: "__COMPANION_OFF__", handled: true };
+        if (arg === "on")
+            return { output: "__COMPANION_ON__", handled: true };
+        return { output: "Usage: /companion off or /companion on", handled: true };
+    });
+    register("fast", "Toggle fast mode (optimized for speed)", () => {
+        return { output: "", handled: true, toggleFastMode: true };
+    });
+    register("keys", "Show keyboard shortcuts", () => {
+        const bindings = loadKeybindings();
+        const shortcuts = [
+            "Keyboard Shortcuts:",
+            "",
+            "  Navigation:",
+            "    ↑ / ↓           Input history",
+            "    Tab              Cycle autocomplete suggestions",
+            "    Escape           Cancel / clear autocomplete",
+            "    Ctrl+C           Abort current request / exit",
+            "    Scroll wheel     Scroll through messages",
+            "",
+            "  Editing:",
+            "    Alt+Enter        Insert newline (multi-line input)",
+            "    Ctrl+A           Move cursor to start of line",
+            "    Ctrl+E           Move cursor to end of line",
+            "",
+            "  Display:",
+            "    Ctrl+K           Toggle code block expansion",
+            "    Ctrl+O           Toggle thinking block expansion",
+            "    Tab (in output)  Expand/collapse tool call output",
+            "",
+            "  Custom keybindings (~/.oh/keybindings.json):",
+        ];
+        for (const b of bindings) {
+            shortcuts.push(`    ${b.key.padEnd(18)} ${b.action}`);
+        }
+        shortcuts.push("", "  Session:", "    /vim              Toggle Vim mode", "    /browse           Interactive session browser", "    /theme dark|light Switch theme");
+        return { output: shortcuts.join("\n"), handled: true };
+    });
+    register("effort", "Set reasoning effort level (low/medium/high/max)", (args) => {
+        const level = args.trim().toLowerCase();
+        const valid = ["low", "medium", "high", "max"];
+        if (!valid.includes(level)) {
+            return {
+                output: `Usage: /effort <${valid.join("|")}>\n\nlow    — fast, minimal reasoning\nmedium — balanced (default)\nhigh   — thorough reasoning\nmax    — maximum depth (Opus only)`,
+                handled: true,
+            };
+        }
+        return { output: `Effort level set to: ${level}`, handled: true };
+    });
+    register("sandbox", "Show sandbox status and restrictions", () => {
+        const { sandboxStatus } = require("../harness/sandbox.js");
+        return { output: `${sandboxStatus()}\n\nConfigure in .oh/config.yaml under sandbox:`, handled: true };
+    });
+    register("permissions", "View or change permission mode", (args, ctx) => {
+        const mode = args.trim().toLowerCase();
+        if (!mode) {
+            return {
+                output: `Current permission mode: ${ctx.permissionMode}\n\nAvailable modes:\n  ask            Prompt for medium/high risk (default)\n  trust          Auto-approve everything\n  deny           Only low-risk read-only\n  acceptEdits    Auto-approve file edits\n  plan           Read-only mode\n  auto           Auto-approve, block dangerous bash\n  bypassPermissions  CI/CD only`,
+                handled: true,
+            };
+        }
+        const valid = ["ask", "trust", "deny", "acceptedits", "plan", "auto", "bypasspermissions"];
+        if (!valid.includes(mode)) {
+            return { output: `Unknown mode: ${mode}. Valid: ${valid.join(", ")}`, handled: true };
+        }
+        return {
+            output: `Permission mode set to: ${mode}\n(Note: takes effect for new tool calls in this session)`,
+            handled: true,
+        };
+    });
+    register("allowed-tools", "View tool permission rules", () => {
+        const config = readOhConfig();
+        const rules = config?.toolPermissions;
+        if (!rules || rules.length === 0) {
+            return {
+                output: 'No custom tool permission rules configured.\n\nAdd rules to .oh/config.yaml:\n\ntoolPermissions:\n  - tool: Bash\n    action: ask\n    pattern: "^rm .*"',
+                handled: true,
+            };
+        }
+        const lines = rules.map((r) => {
+            const parts = [`  ${r.tool}: ${r.action}`];
+            if (r.pattern)
+                parts.push(`(pattern: ${r.pattern})`);
+            return parts.join(" ");
+        });
+        return { output: `Tool permission rules:\n${lines.join("\n")}`, handled: true };
+    });
+    register("vim", "Toggle Vim mode", () => {
+        return { output: "__TOGGLE_VIM__", handled: true };
+    });
+    register("login", "Set API key for current provider", (args, ctx) => {
+        const key = args.trim();
+        if (!key) {
+            const envHint = ctx.providerName === "anthropic"
+                ? "ANTHROPIC_API_KEY"
+                : ctx.providerName === "openai"
+                    ? "OPENAI_API_KEY"
+                    : `${ctx.providerName.toUpperCase()}_API_KEY`;
+            return {
+                output: `Usage: /login <api-key>\n\nAlternatively, set the ${envHint} environment variable.\nCurrent provider: ${ctx.providerName}`,
+                handled: true,
+            };
+        }
+        return {
+            output: `API key set for ${ctx.providerName}. (Takes effect for new requests in this session.)`,
+            handled: true,
+        };
+    });
+    register("logout", "Clear API key for current provider", (_args, ctx) => {
+        return {
+            output: `API key cleared for ${ctx.providerName}. Set via environment variable or /login to re-authenticate.`,
+            handled: true,
+        };
+    });
+    register("terminal-setup", "Terminal configuration hints", () => {
+        const lines = [
+            "Terminal Setup Hints:",
+            "",
+            "  Recommended terminal: Windows Terminal, iTerm2, Alacritty, or Kitty",
+            "  Font: Use a Nerd Font (e.g., FiraCode Nerd Font) for icon support",
+            "  Minimum size: 80x24 characters",
+            "",
+            "  Environment variables:",
+            "    TERM_PROGRAM     Your terminal emulator",
+            "    COLORTERM        Set to 'truecolor' for full color support",
+            "    FORCE_COLOR=1    Force color output in CI environments",
+            "",
+            "  Shell: bash or zsh recommended. Fish is supported but less tested.",
+            "",
+            "  If you see broken characters, ensure your terminal supports UTF-8.",
+        ];
+        return { output: lines.join("\n"), handled: true };
+    });
+    register("verbose", "Toggle verbose mode", () => {
+        return {
+            output: "Verbose mode toggled. Set OH_VERBOSE=1 in your environment for persistent verbose output.",
+            handled: true,
+        };
+    });
+    register("quiet", "Toggle quiet/minimal output mode", () => {
+        return { output: "Quiet mode toggled. Minimal output will be shown.", handled: true };
+    });
+    register("provider", "Show or switch provider", (args, ctx) => {
+        const provider = args.trim();
+        if (!provider) {
+            const lines = [
+                `Current provider: ${ctx.providerName}`,
+                `Current model:    ${ctx.model}`,
+                "",
+                "Available providers:",
+                "  anthropic   — Claude models (requires ANTHROPIC_API_KEY)",
+                "  openai      — GPT models (requires OPENAI_API_KEY)",
+                "  ollama      — Local models via Ollama",
+                "  openrouter  — Multi-provider gateway (requires OPENROUTER_API_KEY)",
+                "",
+                "Switch with: /provider <name>",
+                "Or restart:  oh --model <provider>/<model>",
+            ];
+            return { output: lines.join("\n"), handled: true };
+        }
+        const valid = ["anthropic", "openai", "ollama", "openrouter"];
+        if (!valid.includes(provider)) {
+            return { output: `Unknown provider: ${provider}. Valid: ${valid.join(", ")}`, handled: true };
+        }
+        return {
+            output: `Provider switching requires a session restart.\nRun: oh --model ${provider}/<model-name>`,
+            handled: true,
+        };
+    });
+}
+//# sourceMappingURL=settings.js.map

package/dist/commands/skills.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Skill management commands — /skill-create, /skill-delete, /skill-edit, /skill-search, /skill-install
+ */
+import type { CommandHandler } from "./types.js";
+export declare function registerSkillCommands(register: (name: string, description: string, handler: CommandHandler) => void): void;
+//# sourceMappingURL=skills.d.ts.map

package/dist/commands/skills.js

@@ -0,0 +1,117 @@
+/**
+ * Skill management commands — /skill-create, /skill-delete, /skill-edit, /skill-search, /skill-install
+ */
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export function registerSkillCommands(register) {
+    register("skill-create", "Create a new skill file", (args) => {
+        const name = args.trim();
+        if (!name)
+            return { output: "Usage: /skill-create <name>", handled: true };
+        if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+            return { output: "Error: Invalid skill name.", handled: true };
+        }
+        const dir = join(process.cwd(), ".oh", "skills");
+        mkdirSync(dir, { recursive: true });
+        const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+        const filePath = join(dir, `${slug}.md`);
+        if (existsSync(filePath)) {
+            return { output: `Skill "${slug}" already exists at ${filePath}`, handled: true };
+        }
+        const template = `---
+name: ${slug}
+description: Describe what this skill does
+trigger: ${slug}
+---
+
+# ${name}
+
+## When to Use
+Describe when this skill should be triggered.
+
+## Procedure
+1. Step one
+2. Step two
+3. Step three
+
+## Pitfalls
+- Common mistakes to avoid
+
+## Verification
+How to confirm the skill worked correctly.
+`;
+        writeFileSync(filePath, template);
+        return { output: `Created skill: ${filePath}\nEdit the file to customize it.`, handled: true };
+    });
+    register("skill-delete", "Delete a skill file", (args) => {
+        const name = args.trim();
+        if (!name)
+            return { output: "Usage: /skill-delete <name>", handled: true };
+        const { findSkill } = require("../harness/plugins.js");
+        const skill = findSkill(name);
+        if (!skill)
+            return { output: `Skill "${name}" not found.`, handled: true };
+        try {
+            const { unlinkSync } = require("node:fs");
+            unlinkSync(skill.filePath);
+            return { output: `Deleted skill: ${skill.filePath}`, handled: true };
+        }
+        catch (err) {
+            return { output: `Error deleting skill: ${err.message}`, handled: true };
+        }
+    });
+    register("skill-edit", "Show skill file path for editing", (args) => {
+        const name = args.trim();
+        if (!name)
+            return { output: "Usage: /skill-edit <name>", handled: true };
+        const { findSkill } = require("../harness/plugins.js");
+        const skill = findSkill(name);
+        if (!skill)
+            return { output: `Skill "${name}" not found.`, handled: true };
+        return { output: `Skill file: ${skill.filePath}\nEdit this file to update the skill.`, handled: true };
+    });
+    register("skill-search", "Search the skills registry", (args) => {
+        const query = args.trim();
+        if (!query)
+            return { output: "Usage: /skill-search <query>", handled: true };
+        import("../harness/skill-registry.js").then(async ({ fetchRegistry, searchRegistry }) => {
+            try {
+                const registry = await fetchRegistry();
+                const results = searchRegistry(registry, query);
+                if (results.length === 0) {
+                    console.log(`No skills found matching "${query}".`);
+                }
+                else {
+                    const lines = results.map((s) => `  ${s.name.padEnd(20)} ${s.description} [${s.tags.join(", ")}]`);
+                    console.log(`Found ${results.length} skill(s):\n${lines.join("\n")}\n\nInstall: /skill-install <name>`);
+                }
+            }
+            catch (err) {
+                console.log(`Registry search failed: ${err.message}`);
+            }
+        });
+        return { output: "Searching skills registry...", handled: true };
+    });
+    register("skill-install", "Install a skill from the registry", (args) => {
+        const name = args.trim();
+        if (!name)
+            return { output: "Usage: /skill-install <name>", handled: true };
+        import("../harness/skill-registry.js").then(async ({ fetchRegistry, installSkill }) => {
+            try {
+                const registry = await fetchRegistry();
+                const skill = registry.skills.find((s) => s.name.toLowerCase() === name.toLowerCase());
+                if (!skill) {
+                    console.log(`Skill "${name}" not found in registry. Try /skill-search first.`);
+                    return;
+                }
+                const path = await installSkill(skill);
+                console.log(`Installed skill "${skill.name}" to ${path}`);
+            }
+            catch (err) {
+                console.log(`Installation failed: ${err.message}`);
+            }
+        });
+        return { output: `Installing skill "${name}"...`, handled: true };
+    });
+}
+//# sourceMappingURL=skills.js.map

package/dist/commands/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared types for the slash command system.
+ */
+import type { Message } from "../types/message.js";
+export type CommandResult = {
+    /** Text output to display */
+    output: string;
+    /** If true, don't send to LLM */
+    handled: boolean;
+    /** If set, clear messages */
+    clearMessages?: boolean;
+    /** If set, update model */
+    newModel?: string;
+    /** If set, replace messages with compacted version */
+    compactedMessages?: Message[];
+    /** If true, open the cybergotchi setup UI */
+    openCybergotchiSetup?: boolean;
+    /** If set, resume this session ID */
+    resumeSessionId?: string;
+    /** If set, prepend this text to the user's prompt before sending to LLM */
+    prependToPrompt?: string;
+    /** If set, toggle fast mode */
+    toggleFastMode?: boolean;
+};
+export type CommandHandler = (args: string, context: CommandContext) => CommandResult;
+export type CommandContext = {
+    messages: Message[];
+    model: string;
+    providerName: string;
+    permissionMode: string;
+    totalCost: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    sessionId: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/types.js

@@ -0,0 +1,5 @@
+/**
+ * Shared types for the slash command system.
+ */
+export {};
+//# sourceMappingURL=types.js.map