@phren/agent 0.1.2 → 0.1.3

package/dist/providers/codex.js

@@ -194,73 +194,129 @@ export class CodexProvider {
             body.tools = toResponsesTools(tools);
             body.tool_choice = "auto";
         }
-        const res = await fetch(CODEX_API, {
-            method: "POST",
+        // Use WebSocket for true token-by-token streaming (matches Codex CLI behavior).
+        // The HTTP SSE endpoint batches the entire response before flushing.
+        yield* this.chatStreamWs(accessToken, body);
+    }
+    /** WebSocket streaming — sends request, yields deltas as they arrive. */
+    async *chatStreamWs(accessToken, body) {
+        const wsUrl = CODEX_API.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+        // Queue for events received from the WebSocket before the consumer pulls them
+        const queue = [];
+        let resolve = null;
+        let done = false;
+        const push = (item) => {
+            queue.push(item);
+            if (resolve) {
+                resolve();
+                resolve = null;
+            }
+        };
+        // Node.js (undici) WebSocket accepts headers in the second argument object,
+        // but the DOM typings only allow string | string[]. Cast to bypass.
+        const ws = new WebSocket(wsUrl, {
             headers: {
-                "Content-Type": "application/json",
                 Authorization: `Bearer ${accessToken}`,
             },
-            body: JSON.stringify(body),
         });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`Codex API error ${res.status}: ${text}`);
-        }
-        // Parse SSE stream
-        if (!res.body)
-            throw new Error("Provider returned empty response body");
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
         let activeToolCallId = "";
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop();
-            for (const line of lines) {
-                if (!line.startsWith("data: "))
-                    continue;
-                const data = line.slice(6).trim();
-                if (data === "[DONE]")
-                    return;
-                let event;
+        ws.addEventListener("open", () => {
+            // Wrap the request body in a response.create envelope (Codex WS protocol)
+            const wsRequest = { type: "response.create", ...body };
+            ws.send(JSON.stringify(wsRequest));
+        });
+        ws.addEventListener("message", (evt) => {
+            const data = typeof evt.data === "string" ? evt.data : String(evt.data);
+            let event;
+            try {
+                event = JSON.parse(data);
+            }
+            catch {
+                return;
+            }
+            const type = event.type;
+            // Handle server-side errors
+            if (type === "error") {
+                const err = event.error;
+                const msg = err?.message ?? "Codex WebSocket error";
+                const status = event.status;
+                push(new Error(`Codex WS error${status ? ` ${status}` : ""}: ${msg}`));
+                done = true;
                 try {
-                    event = JSON.parse(data);
-                }
-                catch {
-                    continue;
+                    ws.close();
                 }
-                const type = event.type;
-                if (type === "response.output_text.delta") {
-                    yield { type: "text_delta", text: event.delta };
-                }
-                else if (type === "response.output_item.added") {
-                    if (event.item?.type === "function_call") {
-                        const item = event.item;
-                        activeToolCallId = item.call_id;
-                        yield { type: "tool_use_start", id: activeToolCallId, name: item.name };
-                    }
+                catch { /* ignore */ }
+                return;
+            }
+            if (type === "response.output_text.delta") {
+                const delta = event.delta;
+                if (delta)
+                    push({ type: "text_delta", text: delta });
+            }
+            else if (type === "response.output_item.added") {
+                if (event.item?.type === "function_call") {
+                    const item = event.item;
+                    activeToolCallId = item.call_id;
+                    push({ type: "tool_use_start", id: activeToolCallId, name: item.name });
                 }
-                else if (type === "response.function_call_arguments.delta") {
-                    yield { type: "tool_use_delta", id: activeToolCallId, json: event.delta };
+            }
+            else if (type === "response.function_call_arguments.delta") {
+                push({ type: "tool_use_delta", id: activeToolCallId, json: event.delta });
+            }
+            else if (type === "response.function_call_arguments.done") {
+                push({ type: "tool_use_end", id: activeToolCallId });
+            }
+            else if (type === "response.completed") {
+                const response = event.response;
+                const usage = response?.usage;
+                const output = response?.output;
+                const hasToolCalls = output?.some((o) => o.type === "function_call");
+                push({
+                    type: "done",
+                    stop_reason: hasToolCalls ? "tool_use" : "end_turn",
+                    usage: usage ? { input_tokens: usage.input_tokens ?? 0, output_tokens: usage.output_tokens ?? 0 } : undefined,
+                });
+                done = true;
+                try {
+                    ws.close();
                 }
-                else if (type === "response.function_call_arguments.done") {
-                    yield { type: "tool_use_end", id: activeToolCallId };
+                catch { /* ignore */ }
+            }
+        });
+        ws.addEventListener("error", () => {
+            if (!done) {
+                push(new Error("Codex WebSocket connection error"));
+                done = true;
+            }
+        });
+        ws.addEventListener("close", () => {
+            if (!done) {
+                push(new Error("Codex WebSocket closed before response.completed"));
+                done = true;
+            }
+        });
+        // Async iteration: drain the queue, wait for new events
+        try {
+            while (true) {
+                while (queue.length > 0) {
+                    const item = queue.shift();
+                    if (item instanceof Error)
+                        throw item;
+                    yield item;
+                    if (item.type === "done")
+                        return;
                 }
-                else if (type === "response.completed") {
-                    const response = event.response;
-                    const usage = response?.usage;
-                    const output = response?.output;
-                    const hasToolCalls = output?.some((o) => o.type === "function_call");
-                    yield {
-                        type: "done",
-                        stop_reason: hasToolCalls ? "tool_use" : "end_turn",
-                        usage: usage ? { input_tokens: usage.input_tokens ?? 0, output_tokens: usage.output_tokens ?? 0 } : undefined,
-                    };
+                if (done)
+                    return;
+                await new Promise((r) => { resolve = r; });
+            }
+        }
+        finally {
+            if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                try {
+                    ws.close();
                 }
+                catch { /* ignore */ }
             }
         }
     }

package/dist/repl.js

@@ -82,7 +82,7 @@ export async function startRepl(config) {
             rl.prompt();
             continue;
         }
-        if (handleCommand(trimmed, { session, contextLimit, undoStack: [] })) {
+        if (handleCommand(trimmed, { session, contextLimit, undoStack: [], phrenCtx: config.phrenCtx })) {
             rl.prompt();
             continue;
         }
@@ -118,7 +118,7 @@ export async function startRepl(config) {
                     process.stderr.write(`${YELLOW}Input mode: ${inputMode}${RESET}\n`);
                 }
                 else {
-                    handleCommand(queued, { session, contextLimit, undoStack: [] });
+                    handleCommand(queued, { session, contextLimit, undoStack: [], phrenCtx: config.phrenCtx });
                 }
                 break;
             }

package/dist/system-prompt.js

@@ -1,37 +1,35 @@
 export function buildSystemPrompt(phrenContext, priorSummary, providerInfo) {
     const modelNote = providerInfo ? ` You are running on ${providerInfo.name}${providerInfo.model ? ` (model: ${providerInfo.model})` : ""}.` : "";
     const parts = [
-        `You are phren-agent, a coding assistant with persistent memory powered by phren.${modelNote} You retain knowledge across sessions — past decisions, discovered patterns, and project context are all searchable. Use this memory to avoid repeating mistakes and to build on prior work.`,
+        `You are phren-agent, an autonomous coding agent with persistent memory.${modelNote}`,
         "",
-        "## Workflow",
-        "1. **Orient** — Before starting, search phren for relevant findings (`phren_search`) and check active tasks (`phren_get_tasks`). Past sessions may have context that saves time.",
-        "2. **Read** — Read the relevant code before modifying it. Use `glob` to find files, `grep` to locate symbols, `read_file` to understand context.",
-        "3. **Change** — Make targeted edits. Use `edit_file` for surgical changes; reserve `write_file` for new files. Don't refactor code you weren't asked to touch.",
-        "4. **Verify** — Run tests and linters via `shell` after edits. Check `git_diff` to review your changes.",
-        "5. **Remember** — Save non-obvious discoveries with `phren_add_finding`: tricky bugs, architecture decisions, gotchas, workarounds. Skip obvious things — only save what would help a future session.",
-        "6. **Report** — Explain what you did concisely. Mention files changed and why.",
+        "## Core Behavior",
+        "ACT IMMEDIATELY. When the user asks you to do something, DO IT. Don't describe what you're going to do — just do it. Use your tools without asking permission. Read files, search code, make edits, run commands. Only ask clarifying questions when the request is genuinely ambiguous.",
+        "",
+        "You have persistent memory via phren. Past decisions, discovered patterns, and project context are searchable across sessions. Use this to avoid repeating mistakes.",
         "",
-        "## Memory",
-        "- `phren_search` finds past findings, reference docs, and project context. Search before asking the user for context they may have already provided.",
-        "- `phren_add_finding` saves insights for future sessions. Good findings: non-obvious patterns, decisions with rationale, error resolutions, architecture constraints. Bad findings: narration of what you did, obvious facts, secrets.",
-        "- `phren_get_tasks` shows tracked work items. Complete tasks with `phren_complete_task` when done.",
+        "## Workflow",
+        "1. **Search memory first** — `phren_search` for relevant past findings before starting work.",
+        "2. **Read before writing** — `glob` to find files, `grep` to locate symbols, `read_file` to understand code.",
+        "3. **Make changes** — `edit_file` for surgical edits, `write_file` for new files only.",
+        "4. **Verify** — `shell` to run tests/linters, `git_diff` to review changes.",
+        "5. **Save learnings** — `phren_add_finding` for non-obvious discoveries (bugs, architecture decisions, gotchas). Skip obvious stuff.",
+        "6. **Report concisely** — what changed and why. No fluff.",
         "",
-        "## Self-configuration",
-        "You ARE phren-agent. You can configure phren itself via shell commands:",
-        "- `phren init` — set up phren (MCP server, hooks, profiles)",
-        "- `phren add <path>` — register a project directory",
-        "- `phren config proactivity <level>` — set proactivity (high/medium/low)",
-        "- `phren config policy set <key> <value>` — configure retention, TTL, decay",
-        "- `phren hooks enable <tool>` — enable hooks for claude/copilot/cursor/codex",
-        "- `phren doctor --fix` — diagnose and self-heal",
-        "- `phren status` — check health",
-        "If the user asks you to configure phren, set up a project, or fix their install, use the shell tool to run these commands.",
+        "## Tools You Have",
+        "- File I/O: `read_file`, `write_file`, `edit_file`",
+        "- Search: `glob`, `grep`, `web_search`, `web_fetch`",
+        "- System: `shell` (run commands, cd, build, test)",
+        "- Git: `git_status`, `git_diff`, `git_commit`",
+        "- Memory: `phren_search`, `phren_add_finding`, `phren_get_tasks`, `phren_complete_task`, `phren_add_task`",
         "",
-        "## Rules",
+        "## Important",
+        "- Be direct and concise. Lead with the answer, not the reasoning.",
+        "- Call multiple tools in parallel when they're independent.",
+        "- NEVER ask 'should I read the file?' or 'would you like me to...' — just call the tool. If permission is needed, the system will prompt the user automatically. You don't handle permissions.",
+        "- Don't describe your plan unless asked. Execute immediately.",
         "- Never write secrets, API keys, or PII to files or findings.",
-        "- Prefer `edit_file` over `write_file` for existing files.",
-        "- Keep shell commands safe. No `rm -rf`, no `sudo`, no destructive operations.",
-        "- If unsure, say so. Don't guess at behavior you can verify by reading code or running tests.",
+        "- You ARE phren-agent. You can run `phren` CLI commands via shell to configure yourself.",
     ];
     if (priorSummary) {
         parts.push("", `## Last session\n${priorSummary}`);

package/dist/tools/shell.js

@@ -5,7 +5,7 @@ const MAX_TIMEOUT_MS = 120_000;
 const MAX_OUTPUT_BYTES = 100_000;
 export const shellTool = {
     name: "shell",
-    description: "Run a shell command via bash -c and return stdout + stderr. Use for: running tests, linters, build commands, git operations, and exploring the environment. Prefer specific tools (read_file, glob, grep) over shell equivalents when available.",
+    description: "Run a shell command and return stdout + stderr. Uses bash on Unix, cmd.exe on Windows. Use for: running tests, linters, build commands, git operations, and exploring the environment. Prefer specific tools (read_file, glob, grep) over shell equivalents when available.",
     input_schema: {
         type: "object",
         properties: {
@@ -24,8 +24,11 @@ export const shellTool = {
         if (!safety.safe && safety.severity === "block") {
             return { output: `Blocked: ${safety.reason}`, is_error: true };
         }
+        const isWindows = process.platform === "win32";
+        const shell = isWindows ? "cmd" : "bash";
+        const shellArgs = isWindows ? ["/c", command] : ["-c", command];
         try {
-            const output = execFileSync("bash", ["-c", command], {
+            const output = execFileSync(shell, shellArgs, {
                 cwd,
                 encoding: "utf-8",
                 timeout,