@apolloyh/apollo-agent 0.1.0

package/dist/goal/goal-mode.js

@@ -0,0 +1,141 @@
+/**
+ * Goal mode — pursue a user goal until done (open-ended autonomous loop).
+ * Differs from fixed 4-phase workflow: steps are free-form; exit via markers or /goal stop.
+ */
+export function createGoal(goal, maxIterations = 12, criteria = []) {
+    return {
+        goal: goal.trim(),
+        status: "active",
+        criteria,
+        progress: [],
+        iteration: 0,
+        maxIterations,
+        startedAt: new Date().toISOString(),
+    };
+}
+export function goalStatusBar(g, color) {
+    const dim = color ? "\x1b[90m" : "";
+    const reset = color ? "\x1b[0m" : "";
+    const green = color ? "\x1b[32m" : "";
+    const red = color ? "\x1b[31m" : "";
+    const yellow = color ? "\x1b[33m" : "";
+    const blue = color ? "\x1b[38;2;96;165;250m" : "";
+    let mark = "◉";
+    let c = yellow;
+    if (g.status === "completed") {
+        mark = "●";
+        c = green;
+    }
+    else if (g.status === "failed") {
+        mark = "●";
+        c = red;
+    }
+    else if (g.status === "blocked" || g.status === "paused") {
+        mark = "○";
+        c = dim;
+    }
+    const head = color ? `${blue}Goal${reset}` : "Goal";
+    const lines = [
+        `\n${head}  ${c}${mark} ${g.status}${reset}  ·  iter ${g.iteration}/${g.maxIterations}`,
+        `${dim}${g.goal}${reset}`,
+    ];
+    if (g.criteria.length) {
+        lines.push(`${dim}criteria:${reset}`);
+        for (const cr of g.criteria.slice(0, 5))
+            lines.push(`${dim}  · ${cr}${reset}`);
+    }
+    if (g.progress.length) {
+        lines.push(`${dim}progress:${reset}`);
+        for (const pr of g.progress.slice(-5))
+            lines.push(`${dim}  · ${pr}${reset}`);
+    }
+    if (g.lastBlockedReason) {
+        lines.push(`${yellow}blocked: ${g.lastBlockedReason}${reset}`);
+    }
+    return lines.join("\n") + "\n";
+}
+export function goalSystemExtra(g) {
+    const criteria = g.criteria.length > 0
+        ? g.criteria.map((c) => `- ${c}`).join("\n")
+        : "- Goal is achieved when the user's request is fully satisfied and verified when possible.";
+    const progress = g.progress.length > 0
+        ? g.progress
+            .slice(-8)
+            .map((p) => `- ${p}`)
+            .join("\n")
+        : "- (none yet)";
+    return `# Goal Mode (ACTIVE)
+You are autonomously pursuing a **goal**. Keep working until it is done.
+
+## Goal
+${g.goal}
+
+## Success criteria
+${criteria}
+
+## Progress so far
+${progress}
+
+## Iteration
+${g.iteration} / ${g.maxIterations}
+
+## Rules
+1. Every turn, make concrete progress (tools, edits, research). Do not only restate the goal.
+2. Prefer Task(Explore) for research and Task(general-purpose) for implementation when isolation helps.
+3. After meaningful progress, emit exactly one line:
+   GOAL_PROGRESS:<short note of what you did>
+4. When fully done and verified, emit:
+   GOAL_DONE:<one-line summary of outcome>
+5. If you need the user (missing secret, product choice, destructive confirm), emit:
+   GOAL_BLOCKED:<what you need>
+   Then stop acting until they reply.
+6. If impossible after honest effort, emit:
+   GOAL_FAILED:<reason>
+7. Do not claim GOAL_DONE unless criteria are met.
+8. Keep user-facing text concise; put process detail in tools / progress markers.`;
+}
+/** Parse model markers and update goal state. */
+export function applyGoalMarkers(g, text) {
+    let next = { ...g, progress: [...g.progress] };
+    for (const m of text.matchAll(/GOAL_PROGRESS:([^\n]+)/g)) {
+        const note = (m[1] ?? "").trim();
+        if (note)
+            next.progress.push(note);
+    }
+    for (const m of text.matchAll(/GOAL_BLOCKED:([^\n]+)/g)) {
+        next = {
+            ...next,
+            status: "blocked",
+            lastBlockedReason: (m[1] ?? "").trim(),
+        };
+    }
+    for (const m of text.matchAll(/GOAL_FAILED:([^\n]+)/g)) {
+        next = {
+            ...next,
+            status: "failed",
+            completedAt: new Date().toISOString(),
+            lastBlockedReason: (m[1] ?? "").trim(),
+            progress: [...next.progress, `failed: ${(m[1] ?? "").trim()}`],
+        };
+    }
+    for (const m of text.matchAll(/GOAL_DONE:([^\n]+)/g)) {
+        next = {
+            ...next,
+            status: "completed",
+            completedAt: new Date().toISOString(),
+            progress: [...next.progress, `done: ${(m[1] ?? "").trim()}`],
+        };
+    }
+    return next;
+}
+export function shouldAutoContinue(g) {
+    return g.status === "active" && g.iteration < g.maxIterations;
+}
+export function nextGoalContinuePrompt(g) {
+    return [
+        `Continue Goal mode (iteration ${g.iteration + 1}/${g.maxIterations}).`,
+        `Goal: ${g.goal}`,
+        "Make the next concrete step. Use tools as needed.",
+        "End with GOAL_PROGRESS, GOAL_DONE, GOAL_BLOCKED, or GOAL_FAILED as appropriate.",
+    ].join("\n");
+}

package/dist/hooks/runner.d.ts

@@ -0,0 +1,43 @@
+import type { JsonObject, ToolRisk } from "../types.js";
+export type HookDecision = {
+    allow: boolean;
+    message?: string;
+    /** Optional rewritten input */
+    input?: JsonObject;
+};
+export type HookEvent = {
+    phase: "PreToolUse" | "PostToolUse";
+    toolName: string;
+    risk: ToolRisk;
+    input: JsonObject;
+    result?: {
+        content: string;
+        isError?: boolean;
+    };
+};
+export type HookHandler = (event: HookEvent) => Promise<HookDecision | void> | HookDecision | void;
+export type HooksFile = {
+    /** Deny tools by name in PreToolUse */
+    denyTools?: string[];
+    /** Log all tool calls to .apollo/hooks.log */
+    log?: boolean;
+    /** Custom notes shown when a tool is blocked */
+    denyMessage?: string;
+};
+export declare class HookRunner {
+    private readonly workspaceRoot;
+    private file;
+    private handlers;
+    private loaded;
+    private loadError?;
+    constructor(workspaceRoot: string);
+    register(handler: HookHandler): void;
+    load(): Promise<void>;
+    preToolUse(toolName: string, risk: ToolRisk, input: JsonObject): Promise<HookDecision>;
+    postToolUse(toolName: string, risk: ToolRisk, input: JsonObject, result: {
+        content: string;
+        isError?: boolean;
+    }): Promise<void>;
+    private appendLog;
+}
+//# sourceMappingURL=runner.d.ts.map

package/dist/hooks/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/hooks/runner.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGxD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,YAAY,GAAG,aAAa,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,YAAY,GAAG,IAAI,CAAC;AAEnG,MAAM,MAAM,SAAS,GAAG;IACtB,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,8CAA8C;IAC9C,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,qBAAa,UAAU;IAMT,OAAO,CAAC,QAAQ,CAAC,aAAa;IAL1C,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAC,CAAS;gBAEE,aAAa,EAAE,MAAM;IAElD,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAI9B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAcrB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAmBtF,WAAW,CACf,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7C,OAAO,CAAC,IAAI,CAAC;YAiBF,SAAS;CAMxB"}

package/dist/hooks/runner.js

@@ -0,0 +1,94 @@
+/**
+ * Tool hooks — PreToolUse / PostToolUse (CC-inspired).
+ * Config: .apollo/hooks.json
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { safeRealResolve } from "../utils.js";
+export class HookRunner {
+    workspaceRoot;
+    file = {};
+    handlers = [];
+    loaded = false;
+    loadError;
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+    }
+    register(handler) {
+        this.handlers.push(handler);
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const file = await safeRealResolve(this.workspaceRoot, path.join(this.workspaceRoot, ".apollo", "hooks.json"));
+            const raw = await fs.readFile(file, "utf8");
+            this.file = JSON.parse(raw);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                this.loadError = `Failed to load .apollo/hooks.json: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        }
+        this.loaded = true;
+    }
+    async preToolUse(toolName, risk, input) {
+        await this.load();
+        if (this.loadError)
+            return { allow: false, message: this.loadError };
+        if (this.file.denyTools?.includes(toolName)) {
+            return {
+                allow: false,
+                message: this.file.denyMessage ?? `Hook denied tool: ${toolName}`,
+            };
+        }
+        let currentInput = input;
+        for (const h of this.handlers) {
+            const d = await h({ phase: "PreToolUse", toolName, risk, input: currentInput });
+            if (d && d.allow === false)
+                return d;
+            if (d?.input)
+                currentInput = d.input;
+        }
+        if (this.file.log)
+            await this.appendLog({ phase: "PreToolUse", toolName, risk, input: currentInput });
+        return { allow: true, input: currentInput };
+    }
+    async postToolUse(toolName, risk, input, result) {
+        await this.load();
+        if (this.loadError)
+            return;
+        for (const h of this.handlers) {
+            await h({ phase: "PostToolUse", toolName, risk, input, result });
+        }
+        if (this.file.log) {
+            await this.appendLog({
+                phase: "PostToolUse",
+                toolName,
+                risk,
+                input,
+                result: { content: result.content.slice(0, 500), isError: result.isError },
+            });
+        }
+    }
+    async appendLog(entry) {
+        const dir = await safeRealResolve(this.workspaceRoot, path.join(this.workspaceRoot, ".apollo"));
+        await fs.mkdir(dir, { recursive: true });
+        const line = `${JSON.stringify(redactLogValue({ ts: new Date().toISOString(), ...entry }))}\n`;
+        await fs.appendFile(await safeRealResolve(dir, path.join(dir, "hooks.log")), line, "utf8");
+    }
+}
+const SENSITIVE_LOG_KEY = /(?:authorization|password|secret|token|api[_-]?key)/i;
+const PRIVATE_LOG_FIELD = /^(arguments|body|command|content|message|prompt|subject|task|to)$/i;
+function redactLogValue(value, key = "") {
+    if (SENSITIVE_LOG_KEY.test(key) || PRIVATE_LOG_FIELD.test(key)) {
+        const length = typeof value === "string" ? ` (${value.length} chars)` : "";
+        return `[redacted${length}]`;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redactLogValue(item));
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => [childKey, redactLogValue(childValue, childKey)]));
+    }
+    return value;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}