@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/timeline/timeline-store.js

@@ -1,618 +0,0 @@
-/**
- * Timeline Store — third CozoDB instance at `.unerr/timeline.db`.
- *
- * Parallel to graph.db (Layer 2) and facts.db (Layer 9). Holds:
- *   - turns                 : agent-turn rollups (one per closed turn)
- *   - intents               : cross-session task groupings (ST-4)
- *   - intent_sessions       : intent↔session many-to-many (ST-4)
- *   - markers               : agent-emitted mark_* rows (ST-2)
- *   - derived_signals       : mined patterns (hot files, loops, co-changes) (ST-3+)
- *   - signal_reinforcement  : append-only reinforcement events per signal (ST-5)
- *
- * Schema rules (per CLAUDE.md):
- *   - Named Datalog syntax for any relation with 4+ columns.
- *   - All db.run() calls are async — always await.
- *   - Edit in place, no migrations until first public release.
- *
- * Isolation contract: this module NEVER reads or writes graph.db or facts.db.
- * It only opens/owns `.unerr/timeline.db`. Existing Layer 2 / Layer 9 code is
- * untouched.
- */
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-const TIMELINE_DB_FILENAME = "timeline.db";
-/**
- * Open or create timeline.db at `{projectRoot}/.unerr/timeline.db`. Mirrors the
- * factory pattern in `openFactsDb()` so the dynamic-import dance stays uniform.
- */
-export async function openTimelineDb(projectRoot) {
-    const unerrDir = join(projectRoot, ".unerr");
-    mkdirSync(unerrDir, { recursive: true });
-    const dbPath = join(unerrDir, TIMELINE_DB_FILENAME);
-    const isNew = !existsSync(dbPath);
-    const cozoModule = await import("cozo-node");
-    const CozoDbConstructor = cozoModule.default
-        ? cozoModule.default.CozoDb
-        : cozoModule.CozoDb;
-    const db = new CozoDbConstructor("sqlite", dbPath);
-    return { db, isNew, dbPath };
-}
-async function getExistingRelations(db) {
-    const result = await db.run("::relations");
-    return new Set(result.rows.map((row) => row[0]));
-}
-/**
- * Initialise timeline.db schema. Creates only missing relations — safe to call
- * on fresh and existing databases. Schema is intentionally minimal here; the
- * later sprints (ST-3/4/5) add CRUD methods on top.
- */
-export async function initTimelineSchema(db) {
-    const existing = await getExistingRelations(db);
-    if (!existing.has("turns")) {
-        await db.run(`
-      :create turns {
-        turn_id: String
-        =>
-        session_id: String,
-        started_at: Float,
-        ended_at: Float,
-        opened_by: String,
-        closed_reason: String,
-        tool_count: Int,
-        file_count: Int,
-        edit_count: Int,
-        title: String,
-        outcome: String
-      }
-    `);
-    }
-    if (!existing.has("intents")) {
-        await db.run(`
-      :create intents {
-        intent_id: String
-        =>
-        title: String,
-        started_at: Float,
-        last_active_at: Float,
-        file_set: String,
-        file_set_hash: String,
-        status: String,
-        confidence: Float,
-        source: String
-      }
-    `);
-    }
-    if (!existing.has("intent_sessions")) {
-        await db.run(`
-      :create intent_sessions {
-        intent_id: String,
-        session_id: String
-      }
-    `);
-    }
-    if (!existing.has("markers")) {
-        await db.run(`
-      :create markers {
-        marker_id: String
-        =>
-        type: String,
-        text: String,
-        session_id: String,
-        turn_id: String,
-        ts: Float,
-        blocker_ref: String,
-        file_path: String
-      }
-    `);
-    }
-    if (!existing.has("derived_signals")) {
-        await db.run(`
-      :create derived_signals {
-        signal_id: String
-        =>
-        type: String,
-        scope: String,
-        content: String,
-        confidence: Float,
-        first_seen_at: Float,
-        last_seen_at: Float
-      }
-    `);
-    }
-    if (!existing.has("signal_reinforcement")) {
-        await db.run(`
-      :create signal_reinforcement {
-        signal_id: String,
-        ts: Float
-        =>
-        delta: Float,
-        source: String
-      }
-    `);
-    }
-    if (!existing.has("session_files")) {
-        // (session_id, file_path) — records distinct file touches per session for
-        // intent stitching (ST-4). Populated by the bootstrap when a turn closes.
-        await db.run(`
-      :create session_files {
-        session_id: String,
-        file_path: String
-      }
-    `);
-    }
-    if (!existing.has("session_agents")) {
-        // UX-1: which agent (Claude Code, Cursor, Codex, …) drove this session.
-        // Best-effort — populated when the MCP `initialize` handshake provided a
-        // clientInfo.name. Sessions without an identified client get "unknown".
-        await db.run(`
-      :create session_agents {
-        session_id: String
-        =>
-        agent_name: String,
-        first_seen: Float,
-        last_seen: Float
-      }
-    `);
-    }
-}
-// ── Store facade ─────────────────────────────────────────────────────────────
-/**
- * Thin async wrapper around the timeline CozoDB instance. ST-1b only ships a
- * minimal CRUD surface (turns + markers + listings). ST-3/4/5 extend this with
- * intent, signal, and reinforcement methods.
- */
-export class CozoTimelineStore {
-    db;
-    dbPath;
-    isNew;
-    constructor(db, dbPath, isNew) {
-        this.db = db;
-        this.dbPath = dbPath;
-        this.isNew = isNew;
-    }
-    /**
-     * Factory — opens the db and runs schema init. Use this instead of `new`.
-     */
-    static async create(projectRoot) {
-        const { db, dbPath, isNew } = await openTimelineDb(projectRoot);
-        await initTimelineSchema(db);
-        return new CozoTimelineStore(db, dbPath, isNew);
-    }
-    /** Underlying handle for tests and advanced consumers. */
-    getDb() {
-        return this.db;
-    }
-    /**
-     * Upsert a turn rollup. Called when the segmenter emits a turn-close event.
-     */
-    async upsertTurn(turn) {
-        await this.db.run(`
-      ?[turn_id, session_id, started_at, ended_at, opened_by, closed_reason, tool_count, file_count, edit_count, title, outcome] <-
-        [[$turn_id, $session_id, $started_at, $ended_at, $opened_by, $closed_reason, $tool_count, $file_count, $edit_count, $title, $outcome]]
-      :put turns {
-        turn_id
-        =>
-        session_id, started_at, ended_at, opened_by, closed_reason,
-        tool_count, file_count, edit_count, title, outcome
-      }
-    `, turn);
-    }
-    /**
-     * List turns with filters. Newest-first by `started_at`. Supports pagination
-     * (offset + limit) and substring search on `title`.
-     */
-    async listTurns(opts = {}) {
-        const limit = Math.max(1, Math.min(opts.limit ?? 50, 500));
-        const offset = Math.max(0, opts.offset ?? 0);
-        const { whereClause, params } = buildTurnFilter(opts);
-        const query = `
-      ?[turn_id, session_id, started_at, ended_at, opened_by, closed_reason, tool_count, file_count, edit_count, title, outcome] :=
-        *turns{
-          turn_id, session_id, started_at, ended_at, opened_by, closed_reason,
-          tool_count, file_count, edit_count, title, outcome
-        }${whereClause}
-      :order -started_at
-      :offset ${offset}
-      :limit ${limit}
-    `;
-        const result = await this.db.run(query, params);
-        return result.rows.map(rowToTurn);
-    }
-    /**
-     * Total number of turns matching the same filter as `listTurns`. Used for
-     * pagination footers ("page X of Y").
-     */
-    async countTurns(opts = {}) {
-        const { whereClause, params } = buildTurnFilter(opts);
-        const result = await this.db.run(`?[count(turn_id)] := *turns{turn_id, session_id, started_at, ended_at, opened_by, closed_reason, tool_count, file_count, edit_count, title, outcome}${whereClause}`, params);
-        const row = result.rows[0];
-        return row ? Number(row[0]) : 0;
-    }
-    /**
-     * List distinct sessions touched by `turns`, with aggregate stats and the
-     * agent that drove the session (when known). Powers the session + agent
-     * filters in the Timeline page.
-     */
-    async listSessions(opts = {}) {
-        const limit = Math.max(1, Math.min(opts.limit ?? 200, 1000));
-        const filters = [];
-        const params = {};
-        if (typeof opts.fromTs === "number") {
-            filters.push("started_at >= $from_ts");
-            params.from_ts = opts.fromTs;
-        }
-        if (typeof opts.toTs === "number") {
-            filters.push("started_at <= $to_ts");
-            params.to_ts = opts.toTs;
-        }
-        const whereClause = filters.length > 0 ? `, ${filters.join(", ")}` : "";
-        const result = await this.db.run(`?[session_id, min(started_at), max(ended_at), count(turn_id), sum(edit_count), sum(file_count)] :=
-        *turns{turn_id, session_id, started_at, ended_at, edit_count, file_count}${whereClause}
-       :order -max(ended_at)
-       :limit ${limit}`, params);
-        const rows = result.rows.map((r) => ({
-            session_id: r[0],
-            first_seen: r[1],
-            last_seen: r[2],
-            turn_count: r[3],
-            edit_count: r[4],
-            file_count: r[5],
-            agent_name: "unknown",
-        }));
-        // Left-join the agent name lookup in a second pass — Cozo's join syntax
-        // doesn't compose cleanly with `:order` over aggregates here.
-        const agentMap = await this.getSessionAgents(rows.map((r) => r.session_id));
-        for (const r of rows) {
-            const a = agentMap.get(r.session_id);
-            if (a)
-                r.agent_name = a;
-        }
-        return rows;
-    }
-    /**
-     * Record (or refresh) the agent name for a session. Called from the bootstrap
-     * on each turn close — first_seen is preserved across calls, last_seen
-     * advances. Best-effort; no-op when agent_name is empty.
-     */
-    async setSessionAgent(sessionId, agentName, nowMs = Date.now()) {
-        if (!agentName || agentName.length === 0)
-            return;
-        const existing = await this.db.run("?[first_seen] := *session_agents{session_id, first_seen}, session_id = $sid", { sid: sessionId });
-        const firstSeen = existing.rows.length > 0 ? existing.rows[0]?.[0] : nowMs;
-        await this.db.run(`?[session_id, agent_name, first_seen, last_seen] <-
-        [[$sid, $name, $first, $last]]
-       :put session_agents {
-         session_id => agent_name, first_seen, last_seen
-       }`, {
-            sid: sessionId,
-            name: agentName,
-            first: firstSeen,
-            last: nowMs,
-        });
-    }
-    /** Lookup the agent name for one session id. Returns null when unknown. */
-    async getSessionAgent(sessionId) {
-        const result = await this.db.run("?[agent_name] := *session_agents{session_id, agent_name}, session_id = $sid", { sid: sessionId });
-        const row = result.rows[0];
-        return row ? row[0] : null;
-    }
-    /** Batched agent lookup — used by listSessions to avoid N+1 queries. */
-    async getSessionAgents(sessionIds) {
-        const map = new Map();
-        if (sessionIds.length === 0)
-            return map;
-        // Cozo doesn't take an `IN` list directly; pull all and filter client-side.
-        const all = await this.db.run("?[session_id, agent_name] := *session_agents{session_id, agent_name}");
-        const wanted = new Set(sessionIds);
-        for (const r of all.rows) {
-            const sid = r[0];
-            if (wanted.has(sid))
-                map.set(sid, r[1]);
-        }
-        return map;
-    }
-    /**
-     * Distinct agent names with session counts. Powers the agent filter
-     * dropdown and the "agents over time" KPI.
-     */
-    async listAgents() {
-        const result = await this.db.run(`?[agent_name, count(session_id), max(last_seen)] :=
-        *session_agents{session_id, agent_name, last_seen}
-       :order -max(last_seen)`);
-        return result.rows.map((r) => ({
-            agent_name: r[0],
-            session_count: r[1],
-            last_seen: r[2],
-        }));
-    }
-    /**
-     * Bucketed activity counts for the heatmap. Returns one row per day in the
-     * `[fromTs, toTs]` range (inclusive), with zeros for empty days.
-     */
-    async getActivityBuckets(opts) {
-        const bucket = opts.bucketMs ?? 24 * 60 * 60_000;
-        const turns = await this.listTurns({
-            fromTs: opts.fromTs,
-            toTs: opts.toTs,
-            limit: 5000,
-        });
-        const map = new Map();
-        // Pre-fill the range so empty days still render.
-        for (let t = bucketStart(opts.fromTs, bucket); t <= opts.toTs; t += bucket) {
-            map.set(t, { ts: t, turns: 0, edits: 0, tools: 0 });
-        }
-        for (const turn of turns) {
-            const b = bucketStart(turn.started_at, bucket);
-            const cur = map.get(b) ?? { ts: b, turns: 0, edits: 0, tools: 0 };
-            cur.turns += 1;
-            cur.edits += turn.edit_count;
-            cur.tools += turn.tool_count;
-            map.set(b, cur);
-        }
-        return [...map.values()].sort((a, b) => a.ts - b.ts);
-    }
-    /** Insert a marker row. Used by ST-2 marker tool handlers. */
-    async insertMarker(marker) {
-        await this.db.run(`
-      ?[marker_id, type, text, session_id, turn_id, ts, blocker_ref, file_path] <-
-        [[$marker_id, $type, $text, $session_id, $turn_id, $ts, $blocker_ref, $file_path]]
-      :put markers {
-        marker_id
-        =>
-        type, text, session_id, turn_id, ts, blocker_ref, file_path
-      }
-    `, marker);
-    }
-    /**
-     * List markers, newest first. ST-3 open-threads uses this to find blockers
-     * without resolutions.
-     */
-    async listMarkers(opts = {}) {
-        const limit = opts.limit ?? 100;
-        const filters = [];
-        if (opts.sessionId)
-            filters.push("session_id = $session_id");
-        if (opts.type)
-            filters.push("type = $type");
-        const filterClause = filters.length > 0 ? `, ${filters.join(", ")}` : "";
-        const query = `
-      ?[marker_id, type, text, session_id, turn_id, ts, blocker_ref, file_path] :=
-        *markers{
-          marker_id, type, text, session_id, turn_id, ts, blocker_ref, file_path
-        }${filterClause}
-      :order -ts
-      :limit ${Math.max(1, Math.min(limit, 500))}
-    `;
-        const params = {};
-        if (opts.sessionId)
-            params.session_id = opts.sessionId;
-        if (opts.type)
-            params.type = opts.type;
-        const result = await this.db.run(query, params);
-        return result.rows.map(rowToMarker);
-    }
-    /**
-     * Record distinct file touches for a session. Called by the bootstrap on
-     * each turn-close so the intent stitcher (ST-4) has a file set to match on.
-     */
-    async recordSessionFiles(sessionId, files) {
-        const list = [...new Set([...files].filter((f) => f.length > 0))];
-        if (list.length === 0)
-            return;
-        // CozoDB :put against a many-row relation works one row at a time.
-        for (const fp of list) {
-            await this.db.run(`?[session_id, file_path] <- [[$session_id, $file_path]]
-         :put session_files { session_id, file_path }`, { session_id: sessionId, file_path: fp });
-        }
-    }
-    async getSessionFiles(sessionId) {
-        const result = await this.db.run("?[file_path] := *session_files{session_id: $session_id, file_path}", { session_id: sessionId });
-        return result.rows.map((r) => r[0]);
-    }
-    async upsertIntent(intent) {
-        await this.db.run(`?[intent_id, title, started_at, last_active_at, file_set, file_set_hash, status, confidence, source] <-
-        [[$intent_id, $title, $started_at, $last_active_at, $file_set, $file_set_hash, $status, $confidence, $source]]
-       :put intents {
-         intent_id
-         => title, started_at, last_active_at, file_set, file_set_hash, status, confidence, source
-       }`, intent);
-    }
-    async listIntents(opts = {}) {
-        const limit = Math.max(1, Math.min(opts.limit ?? 100, 500));
-        const filter = opts.status ? ", status = $status" : "";
-        const query = `?[intent_id, title, started_at, last_active_at, file_set, file_set_hash, status, confidence, source] :=
-        *intents{intent_id, title, started_at, last_active_at, file_set, file_set_hash, status, confidence, source}${filter}
-      :order -last_active_at
-      :limit ${limit}`;
-        const params = {};
-        if (opts.status)
-            params.status = opts.status;
-        const result = await this.db.run(query, params);
-        return result.rows.map((r) => ({
-            intent_id: r[0],
-            title: r[1],
-            started_at: r[2],
-            last_active_at: r[3],
-            file_set: r[4],
-            file_set_hash: r[5],
-            status: r[6],
-            confidence: r[7],
-            source: r[8],
-        }));
-    }
-    async attachSession(intentId, sessionId) {
-        await this.db.run(`?[intent_id, session_id] <- [[$intent_id, $session_id]]
-       :put intent_sessions { intent_id, session_id }`, { intent_id: intentId, session_id: sessionId });
-    }
-    async listIntentSessions(intentId) {
-        const result = await this.db.run("?[session_id] := *intent_sessions{intent_id: $intent_id, session_id}", { intent_id: intentId });
-        return result.rows.map((r) => r[0]);
-    }
-    /**
-     * Reverse lookup: find the intent (if any) attached to a session.
-     */
-    async findIntentForSession(sessionId) {
-        const result = await this.db.run("?[intent_id] := *intent_sessions{intent_id, session_id: $session_id}", { session_id: sessionId });
-        const row = result.rows[0];
-        return row ? row[0] : null;
-    }
-    // ── ST-5: Derived signals + reinforcement ─────────────────────────────
-    async upsertSignal(signal) {
-        await this.db.run(`?[signal_id, type, scope, content, confidence, first_seen_at, last_seen_at] <-
-        [[$signal_id, $type, $scope, $content, $confidence, $first_seen_at, $last_seen_at]]
-       :put derived_signals {
-         signal_id => type, scope, content, confidence, first_seen_at, last_seen_at
-       }`, signal);
-    }
-    async getSignal(signalId) {
-        const result = await this.db.run(`?[signal_id, type, scope, content, confidence, first_seen_at, last_seen_at] :=
-         *derived_signals{signal_id, type, scope, content, confidence, first_seen_at, last_seen_at},
-         signal_id = $signal_id`, { signal_id: signalId });
-        const row = result.rows[0];
-        if (!row)
-            return null;
-        return rowToSignal(row);
-    }
-    async listSignals(opts = {}) {
-        const limit = Math.max(1, Math.min(opts.limit ?? 50, 500));
-        const filters = [];
-        if (opts.type)
-            filters.push("type = $type");
-        if (typeof opts.minConfidence === "number")
-            filters.push("confidence >= $min_confidence");
-        const filterClause = filters.length > 0 ? `, ${filters.join(", ")}` : "";
-        const query = `?[signal_id, type, scope, content, confidence, first_seen_at, last_seen_at] :=
-        *derived_signals{signal_id, type, scope, content, confidence, first_seen_at, last_seen_at}${filterClause}
-      :order -last_seen_at
-      :limit ${limit}`;
-        const params = {};
-        if (opts.type)
-            params.type = opts.type;
-        if (typeof opts.minConfidence === "number")
-            params.min_confidence = opts.minConfidence;
-        const result = await this.db.run(query, params);
-        return result.rows.map(rowToSignal);
-    }
-    async appendReinforcement(signalId, ts, delta, source) {
-        await this.db.run(`?[signal_id, ts, delta, source] <-
-        [[$signal_id, $ts, $delta, $source]]
-       :put signal_reinforcement { signal_id, ts => delta, source }`, {
-            signal_id: signalId,
-            ts,
-            delta,
-            source,
-        });
-    }
-    async getReinforcementHistory(signalId, limit = 10) {
-        const result = await this.db.run(`?[signal_id, ts, delta, source] :=
-        *signal_reinforcement{signal_id, ts, delta, source},
-        signal_id = $signal_id
-      :order -ts
-      :limit ${Math.max(1, Math.min(limit, 100))}`, { signal_id: signalId });
-        return result.rows.map((r) => ({
-            signal_id: r[0],
-            ts: r[1],
-            delta: r[2],
-            source: r[3],
-        }));
-    }
-    /**
-     * Delete signals last seen before `cutoffMs`. Returns the number removed.
-     * Cascades: matching reinforcement history rows are also removed.
-     */
-    async deleteSignalsBefore(cutoffMs) {
-        const stale = await this.db.run(`?[signal_id] := *derived_signals{signal_id, last_seen_at},
-        last_seen_at < $cutoff`, { cutoff: cutoffMs });
-        const ids = stale.rows.map((r) => r[0]);
-        for (const id of ids) {
-            await this.db.run(`?[signal_id] := *derived_signals{signal_id}, signal_id = $signal_id
-         :rm derived_signals { signal_id }`, { signal_id: id });
-            await this.db.run(`?[signal_id, ts] := *signal_reinforcement{signal_id, ts}, signal_id = $signal_id
-         :rm signal_reinforcement { signal_id, ts }`, { signal_id: id });
-        }
-        return ids.length;
-    }
-    /** Cleanly close the underlying CozoDB handle. */
-    close() {
-        this.db.close?.();
-    }
-}
-function rowToSignal(row) {
-    return {
-        signal_id: row[0],
-        type: row[1],
-        scope: row[2],
-        content: row[3],
-        confidence: row[4],
-        first_seen_at: row[5],
-        last_seen_at: row[6],
-    };
-}
-function rowToTurn(row) {
-    return {
-        turn_id: row[0],
-        session_id: row[1],
-        started_at: row[2],
-        ended_at: row[3],
-        opened_by: row[4],
-        closed_reason: row[5],
-        tool_count: row[6],
-        file_count: row[7],
-        edit_count: row[8],
-        title: row[9],
-        outcome: row[10],
-    };
-}
-function rowToMarker(row) {
-    return {
-        marker_id: row[0],
-        type: row[1],
-        text: row[2],
-        session_id: row[3],
-        turn_id: row[4],
-        ts: row[5],
-        blocker_ref: row[6],
-        file_path: row[7],
-    };
-}
-/**
- * Build the Datalog WHERE-clause fragment + params for the turn-filter family
- * (listTurns, countTurns). Centralised so listTurns and countTurns share the
- * same semantics and can't drift.
- */
-function buildTurnFilter(opts) {
-    const filters = [];
-    const params = {};
-    if (opts.sessionId) {
-        filters.push("session_id = $session_id");
-        params.session_id = opts.sessionId;
-    }
-    if (typeof opts.fromTs === "number") {
-        filters.push("started_at >= $from_ts");
-        params.from_ts = opts.fromTs;
-    }
-    if (typeof opts.toTs === "number") {
-        filters.push("started_at <= $to_ts");
-        params.to_ts = opts.toTs;
-    }
-    if (opts.query && opts.query.trim().length > 0) {
-        // Case-insensitive substring search via Cozo's `regex_matches`. The pattern
-        // is regex-escaped so `?` / `.` / `(` / `[` etc. in the user input don't
-        // accidentally turn into wildcards.
-        filters.push("regex_matches(title, $q_re)");
-        params.q_re = `(?i).*${escapeRegex(opts.query.trim())}.*`;
-    }
-    return {
-        whereClause: filters.length > 0 ? `, ${filters.join(", ")}` : "",
-        params,
-    };
-}
-function escapeRegex(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-/** Floor a timestamp to the start of its bucket (e.g. UTC midnight for 24h). */
-function bucketStart(ts, bucketMs) {
-    if (!Number.isFinite(ts) || bucketMs <= 0)
-        return ts;
-    return Math.floor(ts / bucketMs) * bucketMs;
-}

package/dist/tools/coding/bash.js

@@ -1,49 +0,0 @@
-/**
- * Bash Tool — execute shell commands.
- * Requires user permission for non-trivial commands. Streams output.
- */
-import { exec } from "../../utils/exec.js";
-export const bashTool = {
-    name: "bash",
-    description: "Execute a bash command in the project directory. Returns stdout and stderr. " +
-        "Use this for running tests, git commands, build scripts, and other shell operations. " +
-        "Commands time out after 2 minutes.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            command: {
-                type: "string",
-                description: "The bash command to execute",
-            },
-            timeout: {
-                type: "number",
-                description: "Timeout in milliseconds. Default: 120000 (2 minutes)",
-            },
-        },
-        required: ["command"],
-    },
-    isReadOnly: false,
-    requiresPermission: true,
-    async execute(args, ctx) {
-        const command = args.command;
-        const timeout = Math.min(args.timeout ?? 120_000, 600_000);
-        const result = await exec("bash", ["-c", command], {
-            cwd: ctx.cwd,
-            timeout,
-        });
-        if (result.exitCode === 0) {
-            return { content: result.stdout || "(no output)" };
-        }
-        const parts = [];
-        if (result.stdout)
-            parts.push(result.stdout);
-        if (result.stderr)
-            parts.push(result.stderr);
-        if (parts.length === 0)
-            parts.push("Command failed");
-        return {
-            content: `Exit code: ${result.exitCode}\n${parts.join("\n")}`,
-            isError: true,
-        };
-    },
-};