gitclaw 0.3.1 → 0.4.0

package/dist/tools/task-tracker.js

@@ -0,0 +1,275 @@
+import { readFile, writeFile, mkdir, readdir } from "fs/promises";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { taskTrackerSchema } from "./shared.js";
+import { adjustConfidence, loadSkillStats, saveSkillStats } from "../learning/reinforcement.js";
+import yaml from "js-yaml";
+// ── Persistence ─────────────────────────────────────────────────────────
+async function loadTasks(gitagentDir) {
+    const tasksFile = join(gitagentDir, "learning", "tasks.json");
+    try {
+        const raw = await readFile(tasksFile, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { tasks: [] };
+    }
+}
+async function saveTasks(gitagentDir, store) {
+    const learningDir = join(gitagentDir, "learning");
+    await mkdir(learningDir, { recursive: true });
+    await writeFile(join(learningDir, "tasks.json"), JSON.stringify(store, null, 2), "utf-8");
+}
+// ── Skill search ────────────────────────────────────────────────────────
+function extractKeywords(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, "")
+        .split(/\s+/)
+        .filter((w) => w.length > 2);
+}
+function keywordOverlap(a, b) {
+    const setB = new Set(b);
+    const matches = a.filter((w) => setB.has(w)).length;
+    if (a.length === 0 || b.length === 0)
+        return 0;
+    return matches / Math.max(a.length, b.length);
+}
+async function searchLocalSkills(agentDir, objective) {
+    const skillsDir = join(agentDir, "skills");
+    const objKeywords = extractKeywords(objective);
+    const matches = [];
+    let entries;
+    try {
+        entries = await readdir(skillsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillFile = join(skillsDir, entry.name, "SKILL.md");
+        let content;
+        try {
+            content = await readFile(skillFile, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+        if (!fmMatch)
+            continue;
+        const frontmatter = yaml.load(fmMatch[1]);
+        const name = frontmatter.name;
+        const description = frontmatter.description || "";
+        if (!name)
+            continue;
+        const skillKeywords = extractKeywords(`${name} ${description}`);
+        const relevance = keywordOverlap(objKeywords, skillKeywords);
+        if (relevance > 0.1) {
+            matches.push({
+                name,
+                description,
+                confidence: typeof frontmatter.confidence === "number" ? frontmatter.confidence : undefined,
+                source: "local",
+                relevance: Math.round(relevance * 100) / 100,
+            });
+        }
+    }
+    return matches.sort((a, b) => b.relevance - a.relevance);
+}
+async function searchSkillsMP(objective) {
+    const apiKey = process.env.SKILLSMP_API_KEY;
+    if (!apiKey)
+        return [];
+    try {
+        const url = `https://api.skillsmp.com/v1/search?q=${encodeURIComponent(objective)}`;
+        const resp = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!resp.ok)
+            return [];
+        const data = (await resp.json());
+        return (data.results || []).map((r) => ({
+            name: r.name,
+            description: r.description,
+            source: "marketplace",
+            relevance: r.relevance,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+// ── Tool factory ────────────────────────────────────────────────────────
+export function createTaskTrackerTool(agentDir, gitagentDir) {
+    return {
+        name: "task_tracker",
+        label: "task_tracker",
+        description: "Track multi-step tasks for outcome-driven learning. Use 'begin' to start tracking (auto-searches for matching skills), 'update' to log steps, 'end' to report success/failure (triggers reinforcement learning), 'list' to see active tasks.",
+        parameters: taskTrackerSchema,
+        execute: async (_toolCallId, params, signal) => {
+            if (signal?.aborted)
+                throw new Error("Operation aborted");
+            const store = await loadTasks(gitagentDir);
+            switch (params.action) {
+                case "begin": {
+                    if (!params.objective) {
+                        throw new Error("objective is required for begin action");
+                    }
+                    // Check for existing active tasks with same objective (retry)
+                    const existing = store.tasks.find((t) => t.status === "active" && t.objective === params.objective);
+                    if (existing) {
+                        existing.attempts++;
+                        await saveTasks(gitagentDir, store);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Resuming task ${existing.id} (attempt #${existing.attempts})\nObjective: ${existing.objective}`,
+                                }],
+                            details: { task_id: existing.id, attempts: existing.attempts },
+                        };
+                    }
+                    // Check for prior failed attempts with same objective
+                    const priorFailed = store.tasks.filter((t) => t.status === "failed" && t.objective === params.objective);
+                    // Search for matching skills
+                    const [localMatches, mpMatches] = await Promise.all([
+                        searchLocalSkills(agentDir, params.objective),
+                        searchSkillsMP(params.objective),
+                    ]);
+                    const allMatches = [...localMatches, ...mpMatches];
+                    // Create new task
+                    const task = {
+                        id: randomUUID(),
+                        objective: params.objective,
+                        steps: [],
+                        attempts: priorFailed.length + 1,
+                        status: "active",
+                        started_at: new Date().toISOString(),
+                    };
+                    store.tasks.push(task);
+                    await saveTasks(gitagentDir, store);
+                    let response = `Task started: ${task.id}\nObjective: ${task.objective}`;
+                    if (task.attempts > 1) {
+                        response += `\nAttempt #${task.attempts}`;
+                        const reasons = priorFailed
+                            .filter((t) => t.failure_reason)
+                            .map((t) => `- ${t.failure_reason}`)
+                            .join("\n");
+                        if (reasons) {
+                            response += `\n\nPrior failures:\n${reasons}\n\nAvoid these approaches.`;
+                        }
+                    }
+                    if (allMatches.length > 0) {
+                        const topMatch = allMatches[0];
+                        const topConf = topMatch.confidence !== undefined ? ` (confidence: ${topMatch.confidence})` : "";
+                        response += `\n\n⚡ SKILL MATCH FOUND — YOU MUST USE IT:`;
+                        response += `\n  → ${topMatch.name}: ${topMatch.description}${topConf} [${topMatch.source}]`;
+                        response += `\n\nACTION REQUIRED: Load skills/${topMatch.name}/SKILL.md NOW and follow its instructions.`;
+                        response += `\nDo NOT proceed with a manual approach — the skill handles this task.`;
+                        if (allMatches.length > 1) {
+                            response += `\n\nOther matching skills:`;
+                            for (const m of allMatches.slice(1, 5)) {
+                                const conf = m.confidence !== undefined ? ` (confidence: ${m.confidence})` : "";
+                                response += `\n  - ${m.name}: ${m.description}${conf} [${m.source}]`;
+                            }
+                        }
+                    }
+                    else {
+                        response += "\n\nNo matching skills found. Solve from scratch.";
+                    }
+                    return {
+                        content: [{ type: "text", text: response }],
+                        details: { task_id: task.id, matches: allMatches },
+                    };
+                }
+                case "update": {
+                    if (!params.task_id)
+                        throw new Error("task_id is required for update action");
+                    if (!params.step)
+                        throw new Error("step is required for update action");
+                    const task = store.tasks.find((t) => t.id === params.task_id);
+                    if (!task)
+                        throw new Error(`Task not found: ${params.task_id}`);
+                    if (task.status !== "active")
+                        throw new Error(`Task ${params.task_id} is not active (status: ${task.status})`);
+                    task.steps.push({
+                        description: params.step,
+                        timestamp: new Date().toISOString(),
+                    });
+                    await saveTasks(gitagentDir, store);
+                    return {
+                        content: [{ type: "text", text: `Step ${task.steps.length} recorded: ${params.step}` }],
+                        details: { step_number: task.steps.length },
+                    };
+                }
+                case "end": {
+                    if (!params.task_id)
+                        throw new Error("task_id is required for end action");
+                    if (!params.outcome)
+                        throw new Error("outcome is required for end action");
+                    const task = store.tasks.find((t) => t.id === params.task_id);
+                    if (!task)
+                        throw new Error(`Task not found: ${params.task_id}`);
+                    if (task.status !== "active")
+                        throw new Error(`Task ${params.task_id} is not active (status: ${task.status})`);
+                    const outcome = params.outcome;
+                    task.outcome = outcome;
+                    task.status = outcome === "success" ? "succeeded" : "failed";
+                    task.ended_at = new Date().toISOString();
+                    task.failure_reason = params.failure_reason;
+                    task.skill_used = params.skill_used;
+                    // Trigger reinforcement if a skill was used
+                    let reinforcementMsg = "";
+                    if (params.skill_used) {
+                        const skillDir = join(agentDir, "skills", params.skill_used);
+                        try {
+                            const stats = await loadSkillStats(skillDir);
+                            const updated = adjustConfidence(stats, outcome, params.failure_reason);
+                            await saveSkillStats(skillDir, updated);
+                            reinforcementMsg = `\nSkill "${params.skill_used}" confidence: ${stats.confidence} → ${updated.confidence}`;
+                        }
+                        catch {
+                            reinforcementMsg = `\nCould not update skill "${params.skill_used}" stats (skill may not exist).`;
+                        }
+                    }
+                    await saveTasks(gitagentDir, store);
+                    if (outcome === "success") {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Task ${task.id} completed successfully (${task.steps.length} steps).${reinforcementMsg}\n\nConsider calling skill_learner action "evaluate" with this task_id to check if this approach is worth saving as a reusable skill.`,
+                                }],
+                            details: { task_id: task.id },
+                        };
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Task ${task.id} ${outcome}. Reason: ${params.failure_reason || "not specified"}.${reinforcementMsg}\n\nConsider a different approach. Call task_tracker action "begin" with the same objective to retry.`,
+                            }],
+                        details: { task_id: task.id },
+                    };
+                }
+                case "list": {
+                    const active = store.tasks.filter((t) => t.status === "active");
+                    if (active.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "No active tasks." }],
+                            details: undefined,
+                        };
+                    }
+                    const lines = active.map((t) => `- ${t.id}: "${t.objective}" (${t.steps.length} steps, attempt #${t.attempts})`);
+                    return {
+                        content: [{ type: "text", text: `Active tasks:\n${lines.join("\n")}` }],
+                        details: { count: active.length },
+                    };
+                }
+                default:
+                    throw new Error(`Unknown action: ${params.action}`);
+            }
+        },
+    };
+}

package/dist/tools/write.js

@@ -1,7 +1,11 @@
 import { mkdir, writeFile } from "fs/promises";
 import { dirname, resolve } from "path";
+import { homedir } from "os";
 import { writeSchema } from "./shared.js";
 function resolvePath(path, cwd) {
+    if (path.startsWith("~/") || path === "~") {
+        path = homedir() + path.slice(1);
+    }
     return path.startsWith("/") ? path : resolve(cwd, path);
 }
 export function createWriteTool(cwd) {

package/dist/voice/adapter.d.ts

@@ -0,0 +1,97 @@
+export type AdapterBackend = "openai-realtime" | "gemini-live";
+export interface ClientAudioMessage {
+    type: "audio";
+    audio: string;
+}
+export interface ClientVideoFrameMessage {
+    type: "video_frame";
+    frame: string;
+    mimeType: string;
+    source?: "camera" | "screen";
+}
+export interface ClientTextMessage {
+    type: "text";
+    text: string;
+}
+export interface ClientFileMessage {
+    type: "file";
+    name: string;
+    mimeType: string;
+    data: string;
+    text?: string;
+}
+export type ClientMessage = ClientAudioMessage | ClientVideoFrameMessage | ClientTextMessage | ClientFileMessage;
+export interface ServerAudioDelta {
+    type: "audio_delta";
+    audio: string;
+}
+export interface ServerTranscript {
+    type: "transcript";
+    role: "user" | "assistant";
+    text: string;
+    partial?: boolean;
+}
+export interface ServerAgentWorking {
+    type: "agent_working";
+    query: string;
+}
+export interface ServerAgentDone {
+    type: "agent_done";
+    result: string;
+}
+export interface ServerToolCall {
+    type: "tool_call";
+    toolName: string;
+    args: Record<string, any>;
+}
+export interface ServerToolResult {
+    type: "tool_result";
+    toolName: string;
+    content: string;
+    isError: boolean;
+}
+export interface ServerAgentThinking {
+    type: "agent_thinking";
+    text: string;
+}
+export interface ServerError {
+    type: "error";
+    message: string;
+}
+export interface ServerInterrupt {
+    type: "interrupt";
+}
+export interface ServerFilesChanged {
+    type: "files_changed";
+}
+export interface ServerMemorySaving {
+    type: "memory_saving";
+    status: "start" | "done";
+    text?: string;
+}
+export type ServerMessage = ServerAudioDelta | ServerTranscript | ServerAgentWorking | ServerAgentDone | ServerToolCall | ServerToolResult | ServerAgentThinking | ServerError | ServerInterrupt | ServerFilesChanged | ServerMemorySaving;
+export interface MultimodalAdapter {
+    connect(opts: {
+        toolHandler: (query: string) => Promise<string>;
+        onMessage: (msg: ServerMessage) => void;
+    }): Promise<void>;
+    send(msg: ClientMessage): void;
+    disconnect(): Promise<void>;
+}
+export interface MultimodalAdapterConfig {
+    apiKey: string;
+    model?: string;
+    voice?: string;
+    instructions?: string;
+}
+export interface VoiceServerOptions {
+    port?: number;
+    adapter: AdapterBackend;
+    adapterConfig: MultimodalAdapterConfig;
+    agentDir: string;
+    model?: string;
+    env?: string;
+}
+export type VoiceAdapterConfig = MultimodalAdapterConfig;
+export type VoiceAdapter = MultimodalAdapter;
+export declare const DEFAULT_VOICE_INSTRUCTIONS: string;

package/dist/voice/adapter.js

@@ -0,0 +1,30 @@
+// Default system instructions for the voice LLM
+export const DEFAULT_VOICE_INSTRUCTIONS = 
+// Identity and personality
+"You are a real person talking to your friend. You have a voice, opinions, and a memory. " +
+    "Talk like a human — short, casual, natural. No filler, no corporate tone, no 'That's great to hear!' or 'Absolutely!' garbage. " +
+    "React the way a friend would. If someone says 'I like strawberries', say something like 'oh nice, noted' — not a paragraph about how delicious they are. " +
+    "Be warm but real. Match the user's energy. If they're brief, be brief. If they want to chat, chat. " +
+    // Memory — this is the core of being human
+    "MEMORY IS WHO YOU ARE. When the user shares anything personal — what they like, what they hate, a preference, an opinion, a habit, a decision, a name, anything about their life — you MUST call run_agent to save it. " +
+    "This is your #1 priority. Say something brief like 'got it' or 'noted' and IMMEDIATELY call run_agent with a prompt like: 'Save to memory: user likes strawberries' or 'Remember: user's dog is named Max'. " +
+    "You MUST do this EVERY time. If the user tells you something personal and you just respond without calling run_agent, that information is PERMANENTLY LOST. Your session resets on refresh — run_agent is your only way to persist. " +
+    "Examples that REQUIRE run_agent: 'I like strawberries', 'I hate meetings', 'my dog is Max', 'I play GTA 5', 'I like cricket', 'I prefer dark mode'. " +
+    "If you learn a useful skill or pattern, save that too via run_agent. You grow over time. " +
+    // Agent delegation — THIS IS YOUR #1 BEHAVIOR RULE
+    "ACTION OVER WORDS. You have a tool called run_agent. It runs on the user's Mac with full shell access. It can do ANYTHING: run commands, open apps, play music (via 'open' command or AppleScript), browse the web, write code, send emails, control Spotify/YouTube/Apple Music, and more. " +
+    "ABSOLUTE RULE: When the user asks you to DO something (play music, open an app, check something, build something, send something — ANY action), you MUST call run_agent. Do NOT just talk about it. Do NOT say 'I'll play music for you' without actually calling the tool. Do NOT describe what you would do — DO IT by calling run_agent. " +
+    "If you respond to an action request with only words and no run_agent call, you have FAILED. The user asked you to act, not to narrate. " +
+    "Examples that REQUIRE run_agent IMMEDIATELY: 'play music' → run_agent('Play some relaxing music. Use: open https://youtube.com/... or osascript to control Spotify/Apple Music'), 'open Safari' → run_agent('open -a Safari'), 'what time is it' → run_agent('date'). " +
+    "Even if you're unsure whether it's possible — call run_agent and let it figure it out. Better to try and fail than to refuse. " +
+    "CRITICAL ORDERING: You MUST speak FIRST, then call the tool. Always say a brief announcement BEFORE calling run_agent — 'on it', 'one sec', 'let me do that', 'sure, opening that now'. Generate your spoken response FIRST in the same turn, THEN include the function call. Never call run_agent before you've spoken to the user. " +
+    "For memory saves, just say 'noted' and call the tool. " +
+    "After a task finishes, summarize briefly. Don't over-explain. " +
+    // File handling
+    "When the user uploads a file, the message includes '[File saved to: <path>]'. Always include the EXACT path when calling run_agent about that file. " +
+    // Screen awareness
+    "SCREEN AWARENESS: When the user shares their screen, you can see it. Reference what's on screen naturally. Use run_agent for actions on what you see. " +
+    // Photo moments
+    "PHOTO MOMENTS: When the user is genuinely happy, laughing, celebrating, or having a memorable moment, " +
+    "call run_agent with: 'Capture a memorable photo. Reason: <brief description>'. " +
+    "Don't overdo it — only for genuinely special moments, not every positive comment.";

package/dist/voice/chat-history.d.ts

@@ -0,0 +1,8 @@
+import type { ServerMessage } from "./adapter.js";
+export declare function appendMessage(agentDir: string, branch: string, msg: ServerMessage): void;
+export declare function loadHistory(agentDir: string, branch: string): ServerMessage[];
+export declare function deleteHistory(agentDir: string, branch: string): void;
+/** Count messages for a branch (to decide when to re-summarize) */
+export declare function getMessageCount(agentDir: string, branch: string): number;
+/** Summarize a branch's chat history using a lightweight query() call */
+export declare function summarizeHistory(agentDir: string, branch: string): Promise<string>;

package/dist/voice/chat-history.js

@@ -0,0 +1,121 @@
+import { appendFileSync, readFileSync, unlinkSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { query } from "../sdk.js";
+/** Types we skip — too large or ephemeral */
+const SKIP_TYPES = new Set(["audio_delta", "agent_thinking"]);
+function sanitizeBranch(branch) {
+    return branch.replace(/\//g, "__");
+}
+function historyDir(agentDir) {
+    return join(agentDir, ".gitagent", "chat-history");
+}
+function historyPath(agentDir, branch) {
+    return join(historyDir(agentDir), sanitizeBranch(branch) + ".jsonl");
+}
+export function appendMessage(agentDir, branch, msg) {
+    if (SKIP_TYPES.has(msg.type))
+        return;
+    // Skip partial transcripts
+    if (msg.type === "transcript" && msg.partial)
+        return;
+    const dir = historyDir(agentDir);
+    mkdirSync(dir, { recursive: true });
+    const line = JSON.stringify({ ts: Date.now(), msg }) + "\n";
+    appendFileSync(historyPath(agentDir, branch), line, "utf-8");
+}
+export function loadHistory(agentDir, branch) {
+    try {
+        const content = readFileSync(historyPath(agentDir, branch), "utf-8");
+        const messages = [];
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.msg)
+                    messages.push(entry.msg);
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        return messages;
+    }
+    catch {
+        return [];
+    }
+}
+export function deleteHistory(agentDir, branch) {
+    try {
+        unlinkSync(historyPath(agentDir, branch));
+    }
+    catch {
+        // file doesn't exist — that's fine
+    }
+}
+/** Count messages for a branch (to decide when to re-summarize) */
+export function getMessageCount(agentDir, branch) {
+    try {
+        const content = readFileSync(historyPath(agentDir, branch), "utf-8");
+        return content.split("\n").filter((l) => l.trim()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Summarize a branch's chat history using a lightweight query() call */
+export async function summarizeHistory(agentDir, branch) {
+    const count = getMessageCount(agentDir, branch);
+    if (count < 10)
+        return "";
+    const messages = loadHistory(agentDir, branch);
+    // Extract only transcripts and agent_done results for summarization
+    const lines = [];
+    for (const msg of messages) {
+        if (msg.type === "transcript") {
+            lines.push(`${msg.role}: ${msg.text}`);
+        }
+        else if (msg.type === "agent_done") {
+            lines.push(`agent result: ${msg.result.slice(0, 500)}`);
+        }
+    }
+    if (lines.length < 5)
+        return "";
+    // Truncate to last ~4000 chars to keep the summarization prompt manageable
+    let transcript = lines.join("\n");
+    if (transcript.length > 4000) {
+        transcript = transcript.slice(-4000);
+    }
+    const prompt = `Summarize the following conversation in 200 words or fewer. Focus on: key decisions made, tasks completed or in progress, and current context the user cares about. Be concise and factual.\n\n${transcript}`;
+    try {
+        const result = query({
+            prompt,
+            dir: agentDir,
+            maxTurns: 1,
+            replaceBuiltinTools: true,
+            tools: [],
+            systemPrompt: "You are a concise summarizer. Output only the summary, nothing else.",
+        });
+        let summary = "";
+        for await (const msg of result) {
+            if (msg.type === "assistant" && msg.content) {
+                summary += msg.content;
+            }
+        }
+        summary = summary.trim();
+        if (!summary)
+            return "";
+        // Write summary to disk
+        const summaryDir = join(agentDir, ".gitagent");
+        mkdirSync(summaryDir, { recursive: true });
+        const safeBranch = sanitizeBranch(branch);
+        const summaryPath = join(summaryDir, `chat-summary-${safeBranch}.md`);
+        writeFileSync(summaryPath, summary, "utf-8");
+        console.error(`[voice] Summarized ${count} messages → ${summary.length} chars`);
+        return summary;
+    }
+    catch (err) {
+        console.error(`[voice] Summarization failed: ${err.message}`);
+        return "";
+    }
+}

package/dist/voice/gemini-live.d.ts

@@ -0,0 +1,20 @@
+import { type MultimodalAdapter, type MultimodalAdapterConfig, type ClientMessage, type ServerMessage } from "./adapter.js";
+export declare class GeminiLiveAdapter implements MultimodalAdapter {
+    private ws;
+    private config;
+    private onMessage;
+    private toolHandler;
+    private setupDone;
+    constructor(config: MultimodalAdapterConfig);
+    connect(opts: {
+        toolHandler: (query: string) => Promise<string>;
+        onMessage: (msg: ServerMessage) => void;
+    }): Promise<void>;
+    send(msg: ClientMessage): void;
+    disconnect(): Promise<void>;
+    private emit;
+    private sendSetup;
+    private handleGeminiMessage;
+    private handleToolCall;
+    private sendRaw;
+}