@phren/agent 0.1.1 → 0.1.3

package/dist/system-prompt.js

@@ -1,36 +1,35 @@
-export function buildSystemPrompt(phrenContext, priorSummary) {
+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. 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/phren-add-task.js

@@ -0,0 +1,49 @@
+import { addTasks } from "@phren/cli/data/tasks";
+export function createPhrenAddTaskTool(ctx, sessionId) {
+    return {
+        name: "phren_add_task",
+        description: "Add a new task to the phren task list for a project. " +
+            "Use this to track work items discovered during execution that should be addressed later. " +
+            "Good tasks: TODOs found in code, follow-up work, bugs to fix, tech debt. " +
+            "Bad tasks: obvious next steps, tasks you'll complete in this session.",
+        input_schema: {
+            type: "object",
+            properties: {
+                item: {
+                    type: "string",
+                    description: "Task description. Be specific — include file paths, function names, or error context.",
+                },
+                project: {
+                    type: "string",
+                    description: "Project name. Omit to use current project.",
+                },
+                priority: {
+                    type: "string",
+                    enum: ["high", "medium", "low"],
+                    description: "Task priority. Default: medium.",
+                },
+            },
+            required: ["item"],
+        },
+        async execute(input) {
+            const item = input.item;
+            const project = input.project || ctx.project;
+            const priority = input.priority || "medium";
+            if (!project)
+                return { output: "No project context. Specify a project name.", is_error: true };
+            try {
+                // Format with priority prefix if not medium
+                const taskText = priority !== "medium" ? `[${priority}] ${item}` : item;
+                const result = addTasks(ctx.phrenPath, project, [taskText]);
+                if (result.ok) {
+                    return { output: `Task added to ${project}: ${item}` };
+                }
+                return { output: result.error ?? "Failed to add task.", is_error: true };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { output: `Failed: ${msg}`, is_error: true };
+            }
+        },
+    };
+}

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,

package/dist/tools/web-fetch.js

@@ -0,0 +1,40 @@
+export function createWebFetchTool() {
+    return {
+        name: "web_fetch",
+        description: "Fetch a URL and return its text content. Use for reading documentation, API references, or web pages. Returns plain text (HTML tags stripped). Max 50KB response.",
+        input_schema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The URL to fetch." },
+                max_length: { type: "number", description: "Max response length in characters. Default: 50000." },
+            },
+            required: ["url"],
+        },
+        async execute(input) {
+            const url = input.url;
+            const maxLen = input.max_length || 50_000;
+            try {
+                const res = await fetch(url, {
+                    headers: { "User-Agent": "phren-agent/0.1" },
+                    signal: AbortSignal.timeout(15_000),
+                });
+                if (!res.ok)
+                    return { output: `HTTP ${res.status}: ${res.statusText}`, is_error: true };
+                let text = await res.text();
+                // Strip HTML tags for readability
+                text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+                text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+                text = text.replace(/<[^>]+>/g, " ");
+                text = text.replace(/\s{2,}/g, " ").trim();
+                if (text.length > maxLen) {
+                    text = text.slice(0, maxLen) + `\n\n[truncated at ${maxLen} chars]`;
+                }
+                return { output: text };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { output: `Fetch failed: ${msg}`, is_error: true };
+            }
+        },
+    };
+}

package/dist/tools/web-search.js

@@ -0,0 +1,93 @@
+export function createWebSearchTool() {
+    return {
+        name: "web_search",
+        description: "Search the web for documentation, error messages, library APIs, or any technical information. " +
+            "Returns a list of search results with titles, URLs, and snippets. " +
+            "Use this when you need external information not available in the codebase or phren knowledge base.",
+        input_schema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query. Be specific — include error messages, library names, or version numbers.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results to return. Default: 5.",
+                },
+            },
+            required: ["query"],
+        },
+        async execute(input) {
+            const query = input.query;
+            const limit = Math.min(input.limit || 5, 10);
+            try {
+                const results = await searchDuckDuckGo(query, limit);
+                if (results.length === 0) {
+                    return { output: "No search results found." };
+                }
+                const formatted = results.map((r, i) => `${i + 1}. **${r.title}**\n   ${r.url}\n   ${r.snippet}`).join("\n\n");
+                return { output: formatted };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { output: `Search failed: ${msg}`, is_error: true };
+            }
+        },
+    };
+}
+async function searchDuckDuckGo(query, limit) {
+    const encoded = encodeURIComponent(query);
+    const url = `https://html.duckduckgo.com/html/?q=${encoded}`;
+    const res = await fetch(url, {
+        headers: {
+            "User-Agent": "phren-agent/0.1 (search tool)",
+            "Accept": "text/html",
+        },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok) {
+        throw new Error(`Search returned HTTP ${res.status}`);
+    }
+    const html = await res.text();
+    return parseSearchResults(html, limit);
+}
+function parseSearchResults(html, limit) {
+    const results = [];
+    // DuckDuckGo HTML results are in <div class="result"> blocks
+    // Extract links and snippets using regex (no DOM parser dependency)
+    const resultBlocks = html.match(/<div class="links_main[\s\S]*?<\/div>\s*<\/div>/gi) || [];
+    for (const block of resultBlocks) {
+        if (results.length >= limit)
+            break;
+        // Extract URL from the result link
+        const urlMatch = block.match(/<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>/i);
+        const titleMatch = block.match(/<a[^>]*class="result__a"[^>]*>([\s\S]*?)<\/a>/i);
+        const snippetMatch = block.match(/<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i);
+        if (!urlMatch || !titleMatch)
+            continue;
+        let href = urlMatch[1];
+        // DuckDuckGo wraps URLs through their redirect — extract the actual URL
+        const uddgMatch = href.match(/uddg=([^&]+)/);
+        if (uddgMatch) {
+            href = decodeURIComponent(uddgMatch[1]);
+        }
+        const title = stripHtml(titleMatch[1]).trim();
+        const snippet = snippetMatch ? stripHtml(snippetMatch[1]).trim() : "";
+        if (title && href) {
+            results.push({ title, url: href, snippet });
+        }
+    }
+    return results;
+}
+function stripHtml(html) {
+    return html
+        .replace(/<[^>]+>/g, "")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/\s{2,}/g, " ");
+}