@stfade/pi-read-delegator 1.0.4 → 1.0.6

package/index.d.ts

@@ -1,61 +1,3 @@
-/**
- * index.ts — pi-read-delegator extension entry point
- *
- * Lifecycle:
- *   init(agent)  → load config, check deps, ensure template, enable/disable
- *   enable(agent) → block tools, add system prompt, attach bash filter
- *   disable(agent) → restore tools, remove prompt, detach bash filter
- *
- * Commands:
- *   /read-delegator on     → enable the delegator
- *   /read-delegator off    → disable the delegator
- *   /read-delegator status  → show current status
- */
-import { type AgentWithSubagent } from "./reader-manager";
-/**
- * The Pi agent interface as consumed by pi-read-delegator.
- * Extends the building-block types from sub-modules.
- */
-export interface PiAgent extends AgentWithSubagent {
-    /** Return current tool definitions. */
-    getTools(): Array<{
-        name: string;
-    }>;
-    /** Remove a tool by name. */
-    removeTool(name: string): void;
-    /** Add/re-add a tool definition. */
-    addTool(definition: {
-        name: string;
-        [key: string]: unknown;
-    }): void;
-    /** Append a persistent system message to the conversation. */
-    addSystemMessage(text: string): void;
-    /** Remove a previously-added system message by its exact text. */
-    removeSystemMessage(text: string): void;
-    /** Register a hook that fires BEFORE a tool with the given name is called. */
-    onBeforeToolCall(toolName: string, callback: (params: unknown) => Promise<unknown> | unknown): void;
-    /** Register a Pi command (like /read-delegator on). */
-    registerCommand(name: string, handler: (args: string[]) => Promise<string> | string): void;
-    /** Execute a raw shell command directly on the system. */
-    executeShellCommand(command: string): Promise<{
-        stdout: string;
-        stderr: string;
-    }>;
-    /** Prompt the user for input. */
-    promptUser(message: string): Promise<string>;
-    /** Display a message to the user. */
-    displayMessage(message: string): void;
-    /** Set status bar text. */
-    setStatusBarText(text: string): void;
-}
-/**
- * Initialize the extension.
- *
- * This is the function Pi calls when loading the extension.
- * It returns a lifecycle object with enable() and disable().
- */
-export declare function init(agent: PiAgent): {
-    enable: () => void;
-    disable: () => void;
-};
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function (pi: ExtensionAPI): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,260 +1,240 @@
 "use strict";
-/**
- * index.ts — pi-read-delegator extension entry point
- *
- * Lifecycle:
- *   init(agent)  → load config, check deps, ensure template, enable/disable
- *   enable(agent) → block tools, add system prompt, attach bash filter
- *   disable(agent) → restore tools, remove prompt, detach bash filter
- *
- * Commands:
- *   /read-delegator on     → enable the delegator
- *   /read-delegator off    → disable the delegator
- *   /read-delegator status  → show current status
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = init;
-const config_1 = require("./config");
-const tool_blocker_1 = require("./tool-blocker");
-const bash_filter_1 = require("./bash-filter");
-const reader_manager_1 = require("./reader-manager");
-const ui_1 = require("./ui");
-// ---------------------------------------------------------------------------
-// Module state
-// ---------------------------------------------------------------------------
-let enabled = false;
-let config = null;
-let currentSystemMessage = null;
-// ---------------------------------------------------------------------------
-// Lifecycle: init
-// ---------------------------------------------------------------------------
-/**
- * Initialize the extension.
- *
- * This is the function Pi calls when loading the extension.
- * It returns a lifecycle object with enable() and disable().
- */
-function init(agent) {
-    // 1. Load configuration
-    config = (0, config_1.loadConfig)();
-    // 2. Detect language
-    (0, ui_1.getLanguage)(config.language);
-    // 3. Initialize status bar
-    (0, ui_1.initStatusBar)(agent);
-    // 4. Register commands
-    registerCommands(agent);
-    // 5. Run async init tasks (dependency check, template) in background.
-    //    We do NOT block init — if deps are missing the user will be prompted.
-    initAsync(agent);
-    // Build lifecycle interface
-    const enable = () => doEnable(agent);
-    const disable = () => doDisable(agent);
-    // If config says enabled, auto-enable (synchronous part first)
-    if (config?.enabled) {
-        doEnable(agent);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    return { enable, disable };
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const DEFAULT_CONFIG = {
+    enabled: true,
+    reader_subagent_name: "reader",
+    blocked_tools: ["read", "grep", "find", "ls"],
+    orchestrator_prompt: [
+        "You are an orchestrator. You do NOT have direct file-reading tools.",
+        "For any file reading, searching, or directory listing, use the",
+        "'subagent' tool with agent='reader'.",
+        'Example: subagent(agent: "reader", task: "Find all TS files that import \'lodash\'")',
+        "Never try to use read, grep, find, or ls yourself. Always delegate.",
+    ].join("\n"),
+    language: "auto",
+};
+const READ_BASH_COMMANDS = new Set([
+    "cat",
+    "grep",
+    "find",
+    "ls",
+    "head",
+    "tail",
+    "less",
+    "wc",
+    "nl",
+    "more",
+    "bat",
+    "rg",
+    "fd",
+    "awk",
+    "du",
+    "df",
+    "stat",
+    "file",
+    "which",
+    "where",
+    "type",
+    "dir",
+]);
+function configPath() {
+    return path.join(os.homedir(), ".pi", "agent", "read-delegator.json");
 }
-// ---------------------------------------------------------------------------
-// Async initialization (runs in background)
-// ---------------------------------------------------------------------------
-async function initAsync(agent) {
+function readerPath() {
+    return path.join(os.homedir(), ".pi", "agent", "agents", "reader.md");
+}
+function loadConfig() {
+    const cp = configPath();
     try {
-        // Check pi-subagents dependency
-        await (0, reader_manager_1.checkDependencies)(agent.promptUser);
+        if (fs.existsSync(cp)) {
+            const raw = fs.readFileSync(cp, "utf8");
+            const parsed = JSON.parse(raw);
+            return { ...DEFAULT_CONFIG, ...parsed };
+        }
     }
-    catch (err) {
-        (0, ui_1.logError)("deps_failed");
-        (0, ui_1.logError)("reader_failed", String(err));
-        // Disable the extension if dependencies can't be satisfied
-        doDisable(agent);
-        return;
+    catch {
+        // corrupt file --- fall back to defaults
     }
-    // Ensure reader.md template exists
-    const templateOk = (0, reader_manager_1.ensureReaderTemplate)();
-    if (!templateOk) {
-        (0, ui_1.logWarn)("reader_failed", "Reader template could not be created. Create ~/.pi/agent/agents/reader.md manually.");
+    try {
+        const dir = path.dirname(cp);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(cp, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf8");
+    }
+    catch {
+        // read-only home directory --- ignore
     }
+    return { ...DEFAULT_CONFIG };
 }
-// ---------------------------------------------------------------------------
-// Enable / Disable
-// ---------------------------------------------------------------------------
-function doEnable(agent) {
-    if (enabled) {
-        agent.displayMessage((0, ui_1.msg)("already_blocked"));
-        return;
+function saveConfig(config) {
+    const cp = configPath();
+    try {
+        const dir = path.dirname(cp);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(cp, JSON.stringify(config, null, 2), "utf8");
     }
-    if (!config) {
-        (0, ui_1.logError)("reader_failed", "No configuration loaded.");
-        return;
+    catch {
+        // read-only home directory --- ignore
     }
-    // Block read tools
-    (0, tool_blocker_1.blockTools)(agent, config.blocked_tools);
-    // Add system message
-    currentSystemMessage = config.orchestrator_prompt;
-    agent.addSystemMessage(config.orchestrator_prompt);
-    // Attach bash filter hook
-    attachBashFilter(agent);
-    // Update status
-    enabled = true;
-    (0, ui_1.updateStatusBar)("active");
-    (0, ui_1.log)("enabled");
-    agent.displayMessage((0, ui_1.msg)("enabled"));
 }
-function doDisable(agent) {
-    if (!enabled) {
-        agent.displayMessage((0, ui_1.msg)("already_enabled"));
+async function ensureReaderTemplate() {
+    const rp = readerPath();
+    if (fs.existsSync(rp))
         return;
+    const content = [
+        "---",
+        "name: reader",
+        "description: Token-efficient code reader that returns minimal results.",
+        "tools: read, grep, find, ls",
+        "model: lmstudio/nvidia/nemotron-3-nano-4b",
+        "---",
+        "",
+        "You are a token-efficient analyst. Execute read/search/list tasks and return",
+        "ONLY the essential result. Maximum 10 lines. Use bullet summaries.",
+        "Never dump entire files. Focus only on what was asked.",
+    ].join("\n");
+    try {
+        const dir = path.dirname(rp);
+        fs.mkdirSync(dir, { recursive: true });
+        await fs.promises.writeFile(rp, content, "utf8");
     }
-    // Restore read tools
-    (0, tool_blocker_1.restoreTools)(agent);
-    // Remove system message
-    if (currentSystemMessage) {
-        try {
-            agent.removeSystemMessage(currentSystemMessage);
-        }
-        catch {
-            // Best effort — the message text may have been mutated
-        }
-        currentSystemMessage = null;
+    catch {
+        // read-only home directory --- template creation is best-effort
     }
-    // Detach bash filter (we can't undo onBeforeToolCall, but we set a flag)
-    enabled = false;
-    (0, ui_1.updateStatusBar)("idle");
-    (0, ui_1.log)("disabled");
-    agent.displayMessage((0, ui_1.msg)("disabled"));
 }
-// ---------------------------------------------------------------------------
-// Bash filter hook
-// ---------------------------------------------------------------------------
 /**
- * Attach a before-tool-call hook on the "bash" (and "shell") tools.
+ * Determine which tools should stay active after blocking read tools.
  *
- * When the main model tries to execute a bash command:
- *  - Read commands → forwarded to Reader subagent
- *  - Write commands → executed directly
- *  - Ambiguous → user is prompted
+ * We MUST keep the 'subagent' tool (registered by pi-subagents) active;
+ * otherwise the orchestrator cannot call the reader at all.
  */
-function attachBashFilter(agent) {
-    // Hook both "bash" and "shell" tools, since Pi may expose either.
-    const bashToolNames = ["bash", "shell"];
-    for (const toolName of bashToolNames) {
-        try {
-            agent.onBeforeToolCall(toolName, async (params) => {
-                // Only intercept if the extension is enabled
-                if (!enabled || !config)
-                    return undefined; // undefined = proceed normally
-                const p = params;
-                const command = typeof p.command === "string" ? p.command : "";
-                if (!command)
-                    return undefined; // Let the tool handle the error
-                // Classify the command
-                if ((0, bash_filter_1.isWriteCommand)(command)) {
-                    // Let the raw bash/shell tool execute this directly
-                    return undefined; // undefined → Pi runs the original tool
-                }
-                if ((0, bash_filter_1.isReadCommand)(command)) {
-                    // Forward to Reader subagent
-                    (0, ui_1.log)("reader_calling", command);
-                    try {
-                        const result = await (0, reader_manager_1.callReader)(agent, config, (0, bash_filter_1.wrapForReader)(command));
-                        (0, ui_1.log)("reader_done");
-                        // Return the result directly — Pi will use this as the tool output
-                        // instead of running the original bash command.
-                        return { result, subagent_used: true };
-                    }
-                    catch (err) {
-                        (0, ui_1.logError)("reader_failed", String(err));
-                        // Offer the [R/A/C] dialog
-                        try {
-                            const handled = await (0, reader_manager_1.handleReaderError)(agent, config, config.blocked_tools, err, (0, bash_filter_1.wrapForReader)(command), agent.promptUser);
-                            // If "Allow once" was selected, return a special marker
-                            if (handled.startsWith("[ALLOW_ONCE]")) {
-                                return { result: handled, allow_once: true };
-                            }
-                            // Retry succeeded — return the result
-                            return { result: handled, subagent_used: true };
-                        }
-                        catch (finalErr) {
-                            (0, ui_1.updateStatusBar)("error");
-                            return {
-                                error: true,
-                                message: finalErr instanceof Error
-                                    ? finalErr.message
-                                    : "Reader failed",
-                            };
-                        }
-                    }
-                }
-                // Ambiguous command → ask user
-                const answer = await agent.promptUser(`The command "${command}" may read files. Run via Reader? [Y/n]`);
-                if (answer.trim().toLowerCase() === "n" ||
-                    answer.trim().toLowerCase() === "no") {
-                    // Let the original tool run
-                    return undefined;
-                }
-                // Forward to Reader
-                (0, ui_1.log)("reader_calling", command);
-                try {
-                    const result = await (0, reader_manager_1.callReader)(agent, config, (0, bash_filter_1.wrapForReader)(command));
-                    (0, ui_1.log)("reader_done");
-                    return { result, subagent_used: true };
-                }
-                catch (err) {
-                    (0, ui_1.logError)("reader_failed", String(err));
-                    return {
-                        error: true,
-                        message: err instanceof Error ? err.message : "Reader failed",
-                    };
-                }
-            });
-        }
-        catch {
-            // onBeforeToolCall not supported for this tool — no-op
-        }
-    }
+function computeActiveTools(pi, blocked) {
+    const all = pi.getAllTools();
+    const blockedSet = new Set(blocked);
+    // Always keep "subagent" --- it is the bridge to the reader.
+    const forceKeep = new Set(["subagent"]);
+    return all
+        .map((t) => t.name)
+        .filter((name) => forceKeep.has(name) || !blockedSet.has(name));
 }
 // ---------------------------------------------------------------------------
-// Pi commands
+// Extension entry
 // ---------------------------------------------------------------------------
-function registerCommands(agent) {
-    agent.registerCommand("read-delegator", async (args) => {
-        const sub = args[0]?.toLowerCase();
-        switch (sub) {
-            case "on":
-            case "enable": {
-                if (!config) {
-                    config = (0, config_1.loadConfig)();
-                }
-                config.enabled = true;
-                (0, config_1.saveConfig)(config, { silent: true });
-                doEnable(agent);
-                return (0, ui_1.msg)("enabled");
+async function default_1(pi) {
+    const config = loadConfig();
+    // --- ALL actions go inside events. Factory body is registration-only. ---
+    // Inject orchestrator system prompt
+    pi.on("before_agent_start", async (event, _ctx) => {
+        if (!config.enabled)
+            return;
+        return {
+            systemPrompt: event.systemPrompt + "\n\n" + config.orchestrator_prompt,
+        };
+    });
+    // Block tools and set status bar AFTER runtime is ready
+    pi.on("session_start", async (_event, ctx) => {
+        if (config.enabled) {
+            pi.setActiveTools(computeActiveTools(pi, config.blocked_tools));
+        }
+        ctx.ui.setStatus("read-delegator", config.enabled ? "● reader: " + config.reader_subagent_name : undefined);
+    });
+    // Intercept bash read commands
+    pi.on("tool_call", async (event, _ctx) => {
+        if (!config.enabled)
+            return;
+        if (event.toolName === "bash" || event.toolName === "shell") {
+            const command = String(event.input?.command ?? "");
+            const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
+            if (READ_BASH_COMMANDS.has(firstWord)) {
+                return {
+                    block: true,
+                    reason: [
+                        'Use subagent(agent: "' +
+                            config.reader_subagent_name +
+                            '", task: "Execute and summarize: ' +
+                            command +
+                            '")',
+                        "instead of running file-reading commands directly.",
+                    ].join(" "),
+                };
             }
-            case "off":
-            case "disable": {
-                if (config) {
+        }
+    });
+    // Register /read-delegator command
+    pi.registerCommand("read-delegator", {
+        description: "Manage read delegation (on|off|status)",
+        handler: async (args, ctx) => {
+            const sub = args?.trim().toLowerCase() ?? "status";
+            switch (sub) {
+                case "on":
+                case "enable": {
+                    config.enabled = true;
+                    saveConfig(config);
+                    pi.setActiveTools(computeActiveTools(pi, config.blocked_tools));
+                    ctx.ui.notify("🟢 Read delegation enabled", "info");
+                    ctx.ui.setStatus("read-delegator", "● reader: " + config.reader_subagent_name);
+                    return;
+                }
+                case "off":
+                case "disable": {
                     config.enabled = false;
-                    (0, config_1.saveConfig)(config, { silent: true });
+                    saveConfig(config);
+                    pi.setActiveTools(pi.getAllTools().map((t) => t.name));
+                    ctx.ui.notify("🔴 Read delegation disabled", "info");
+                    ctx.ui.setStatus("read-delegator", undefined);
+                    return;
+                }
+                case "status":
+                default: {
+                    const lines = [
+                        "Read delegation: " +
+                            (config.enabled ? "🟢 enabled" : "🔴 disabled"),
+                        "Blocked tools: " + config.blocked_tools.join(", "),
+                        "Reader subagent: " + config.reader_subagent_name,
+                    ];
+                    ctx.ui.notify(lines.join("\n"), "info");
+                    return;
                 }
-                doDisable(agent);
-                return (0, ui_1.msg)("disabled");
-            }
-            case "status": {
-                const status = (0, ui_1.getStatus)();
-                const blocked = (0, tool_blocker_1.getBlockedTools)();
-                return (`pi-read-delegator is ${status}\n` +
-                    `Enabled: ${enabled ? "yes" : "no"}\n` +
-                    `Blocked tools: ${blocked.join(", ") || "(none)"}\n` +
-                    `Reader subagent: ${config?.reader_subagent_name ?? "reader"}\n` +
-                    `Language: ${config?.language ?? "auto"}`);
             }
-            default:
-                return ("Usage:\n" +
-                    "  /read-delegator on     — enable read delegation\n" +
-                    "  /read-delegator off    — disable read delegation\n" +
-                    "  /read-delegator status — show current status");
-        }
+        },
     });
+    // Ensure reader.md template (independent I/O — no Pi API call)
+    await ensureReaderTemplate();
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stfade/pi-read-delegator",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Pi extension that delegates all read operations to a Reader subagent, blocking read tools from the main model",
   "main": "index.js",
   "types": "index.d.ts",