@stfade/pi-read-delegator 1.0.5 → 1.0.7

package/index.d.ts

@@ -1,3 +1,15 @@
+/**
+ * index.ts — pi-read-delegator entry point
+ *
+ * Blocks read tools from the orchestrator and tells it to delegate every
+ * file-read / search task to the 'reader' subagent.
+ *
+ * Architecture:
+ *  - Factory body: registration only (pi.on, pi.registerCommand, ensureReaderTemplate)
+ *  - session_start: dependency check → tool blocking → status bar
+ *  - before_agent_start: inject orchestrator system prompt
+ *  - tool_call: intercept bash read commands → redirect to reader
+ */
 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,4 +1,16 @@
 "use strict";
+/**
+ * index.ts — pi-read-delegator entry point
+ *
+ * Blocks read tools from the orchestrator and tells it to delegate every
+ * file-read / search task to the 'reader' subagent.
+ *
+ * Architecture:
+ *  - Factory body: registration only (pi.on, pi.registerCommand, ensureReaderTemplate)
+ *  - session_start: dependency check → tool blocking → status bar
+ *  - before_agent_start: inject orchestrator system prompt
+ *  - tool_call: intercept bash read commands → redirect to reader
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -37,19 +49,12 @@ 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 config_1 = require("./config");
+const reader_manager_1 = require("./reader-manager");
+const ui_1 = require("./ui");
+// ---------------------------------------------------------------------------
+// Bash read commands — these are intercepted and redirected to reader
+// ---------------------------------------------------------------------------
 const READ_BASH_COMMANDS = new Set([
     "cat",
     "grep",
@@ -74,45 +79,12 @@ const READ_BASH_COMMANDS = new Set([
     "type",
     "dir",
 ]);
-function configPath() {
-    return path.join(os.homedir(), ".pi", "agent", "read-delegator.json");
-}
+// ---------------------------------------------------------------------------
+// Reader template path
+// ---------------------------------------------------------------------------
 function readerPath() {
     return path.join(os.homedir(), ".pi", "agent", "agents", "reader.md");
 }
-function loadConfig() {
-    const cp = configPath();
-    try {
-        if (fs.existsSync(cp)) {
-            const raw = fs.readFileSync(cp, "utf8");
-            const parsed = JSON.parse(raw);
-            return { ...DEFAULT_CONFIG, ...parsed };
-        }
-    }
-    catch {
-        // corrupt file --- fall back to defaults
-    }
-    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 };
-}
-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");
-    }
-    catch {
-        // read-only home directory --- ignore
-    }
-}
 async function ensureReaderTemplate() {
     const rp = readerPath();
     if (fs.existsSync(rp))
@@ -135,60 +107,106 @@ async function ensureReaderTemplate() {
         await fs.promises.writeFile(rp, content, "utf8");
     }
     catch {
-        // read-only home directory --- template creation is best-effort
+        // read-only home directory — template creation is best-effort
     }
 }
-/**
- * Determine which tools should stay active after blocking read tools.
- *
- * We MUST keep the 'subagent' tool (registered by pi-subagents) active;
- * otherwise the orchestrator cannot call the reader at all.
- */
+// ---------------------------------------------------------------------------
+// Tool helpers
+// ---------------------------------------------------------------------------
+/** Determine which tools stay active after blocking read tools.
+ *  Always keeps "subagent" — the bridge to the reader. */
 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));
 }
 // ---------------------------------------------------------------------------
-// Extension entry
+// Extension factory — registration only; actions go inside events
 // ---------------------------------------------------------------------------
 async function default_1(pi) {
-    const config = loadConfig();
-    if (!config.enabled)
-        return;
-    // --- 1. Block read tools ------------------------------------------------
-    const active = computeActiveTools(pi, config.blocked_tools);
-    pi.setActiveTools(active);
-    // --- 2. Inject orchestrator system prompt -------------------------------
+    const config = (0, config_1.loadConfig)();
+    // Detect language
+    (0, ui_1.getLanguage)(config.language);
+    // Quick sync dependency check — interactive prompt is deferred to
+    // session_start where we have access to ctx.ui.confirm().
+    let depsReady = (0, reader_manager_1.isSubagentsInstalled)();
+    let depsChecked = depsReady; // if already ready, no need to check again
+    // -----------------------------------------------------------------------
+    // 1. session_start: dependency check → tool blocking → status bar
+    // -----------------------------------------------------------------------
+    pi.on("session_start", async (_event, ctx) => {
+        // --- Dependency check ---
+        if (!depsChecked) {
+            // Build a prompt function backed by ctx.ui.confirm()
+            const promptFn = async (message) => {
+                const ok = await ctx.ui.confirm("pi-subagents required", message);
+                return ok ? "y" : "n";
+            };
+            depsReady = await (0, reader_manager_1.checkDependencies)(promptFn);
+            depsChecked = true;
+            if (!depsReady) {
+                // Dependency missing and user declined / install failed
+                config.enabled = false;
+                (0, config_1.saveConfig)(config, { silent: true });
+                ctx.ui.setStatus("read-delegator", (0, ui_1.msg)("status_error"));
+                ctx.ui.notify((0, ui_1.msg)("deps_disabled"), "warning");
+                return;
+            }
+            // If deps are now ready, re-enable config in case user previously
+            // declined but now installed manually before session start.
+            if (!config.enabled) {
+                config.enabled = true;
+                (0, config_1.saveConfig)(config, { silent: true });
+            }
+        }
+        // --- Tool blocking ---
+        if (config.enabled) {
+            pi.setActiveTools(computeActiveTools(pi, config.blocked_tools));
+        }
+        ctx.ui.setStatus("read-delegator", config.enabled ? (0, ui_1.msg)("status_active") : (0, ui_1.msg)("status_off"));
+    });
+    // -----------------------------------------------------------------------
+    // 2. before_agent_start: 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}`,
+            systemPrompt: event.systemPrompt + "\n\n" + config.orchestrator_prompt,
         };
     });
-    // --- 3. Intercept bash read commands ------------------------------------
-    //
-    // When the LLM tries `cat some-file` or similar, we block the call and
-    // tell it to route through the reader subagent instead.
+    // -----------------------------------------------------------------------
+    // 3. tool_call: 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 ?? "");
+            if (!command)
+                return;
             const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
             if (READ_BASH_COMMANDS.has(firstWord)) {
                 return {
                     block: true,
                     reason: [
-                        `Use subagent(agent: "reader", task: "Execute and summarize: ${command}")`,
+                        'Use subagent(agent: "' +
+                            config.reader_subagent_name +
+                            '", task: "Execute and summarize: ' +
+                            command +
+                            '")',
                         "instead of running file-reading commands directly.",
                     ].join(" "),
                 };
             }
         }
     });
-    // --- 4. Register /read-delegator command --------------------------------
+    // -----------------------------------------------------------------------
+    // 4. /read-delegator command
+    // -----------------------------------------------------------------------
     pi.registerCommand("read-delegator", {
         description: "Manage read delegation (on|off|status)",
         handler: async (args, ctx) => {
@@ -196,29 +214,34 @@ async function default_1(pi) {
             switch (sub) {
                 case "on":
                 case "enable": {
+                    if (!depsReady) {
+                        ctx.ui.notify("pi-subagents not installed. Install it first to enable read delegation.", "warning");
+                        return;
+                    }
                     config.enabled = true;
-                    saveConfig(config);
-                    const active2 = computeActiveTools(pi, config.blocked_tools);
-                    pi.setActiveTools(active2);
-                    ctx.ui.notify("🟢 Read delegation enabled", "info");
+                    (0, config_1.saveConfig)(config, { silent: true });
+                    pi.setActiveTools(computeActiveTools(pi, config.blocked_tools));
+                    ctx.ui.notify((0, ui_1.msg)("enabled"), "info");
+                    ctx.ui.setStatus("read-delegator", (0, ui_1.msg)("status_active"));
                     return;
                 }
                 case "off":
                 case "disable": {
                     config.enabled = false;
-                    saveConfig(config);
-                    // Restore all tools
+                    (0, config_1.saveConfig)(config, { silent: true });
                     pi.setActiveTools(pi.getAllTools().map((t) => t.name));
-                    ctx.ui.notify("🔴 Read delegation disabled", "info");
-                    ctx.ui.setStatus("read-delegator", undefined);
+                    ctx.ui.notify((0, ui_1.msg)("disabled"), "info");
+                    ctx.ui.setStatus("read-delegator", (0, ui_1.msg)("status_off"));
                     return;
                 }
                 case "status":
                 default: {
                     const lines = [
-                        `Read delegation: ${config.enabled ? "🟢 enabled" : "🔴 disabled"}`,
-                        `Blocked tools: ${config.blocked_tools.join(", ")}`,
-                        `Reader subagent: ${config.reader_subagent_name}`,
+                        "Read delegation: " +
+                            (config.enabled ? "🟢 enabled" : "🔴 disabled"),
+                        "Reader subagent: " + config.reader_subagent_name,
+                        "Dependencies: " + (depsReady ? "✅ ready" : "❌ missing"),
+                        "Blocked tools: " + config.blocked_tools.join(", "),
                     ];
                     ctx.ui.notify(lines.join("\n"), "info");
                     return;
@@ -226,11 +249,9 @@ async function default_1(pi) {
             }
         },
     });
-    // --- 5. Ensure reader.md template ---------------------------------------
+    // -----------------------------------------------------------------------
+    // 5. Background: ensure reader.md template
+    // -----------------------------------------------------------------------
     await ensureReaderTemplate();
-    // --- 6. Status bar ------------------------------------------------------
-    pi.on("session_start", async (_event, ctx) => {
-        ctx.ui.setStatus("read-delegator", `● reader: ${config.reader_subagent_name}`);
-    });
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stfade/pi-read-delegator",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "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",

package/reader-manager.d.ts

@@ -24,14 +24,17 @@ export declare class ReaderError extends Error {
 /**
  * Verify that pi-subagents is installed as a Pi extension.
  *
- * Strategy: check whether the `pi-subagents` npm package is findable.
- * If not, prompt the user to install it. If they agree, install via
- * `pi install pi-subagents` (fallback: `npm install -g pi-subagents`).
+ * - Uses `require.resolve('pi-subagents')` to check installation.
+ * - If not installed, prompts the user to install via `pi install pi-subagents`.
+ * - If the user declines or installation fails, returns false (caller disables the extension).
  *
- * @returns true if installed or successfully installed
- * @throws  if the user declines or installation fails
+ * @returns true if installed or successfully installed; false otherwise
  */
 export declare function checkDependencies(prompt: (message: string) => Promise<string>): Promise<boolean>;
+/**
+ * Quick synchronous check: can we resolve pi-subagents?
+ */
+export declare function isSubagentsInstalled(): boolean;
 /**
  * Ensure the reader.md subagent template exists.
  * If not, copy the bundled template from `templates/reader.md`.

package/reader-manager.js

@@ -44,6 +44,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReaderError = void 0;
 exports.checkDependencies = checkDependencies;
+exports.isSubagentsInstalled = isSubagentsInstalled;
 exports.ensureReaderTemplate = ensureReaderTemplate;
 exports.callReader = callReader;
 exports.handleReaderError = handleReaderError;
@@ -76,28 +77,31 @@ const READER_TEMPLATE_PATH = expandTilde("~/.pi/agent/agents/reader.md");
 /**
  * Verify that pi-subagents is installed as a Pi extension.
  *
- * Strategy: check whether the `pi-subagents` npm package is findable.
- * If not, prompt the user to install it. If they agree, install via
- * `pi install pi-subagents` (fallback: `npm install -g pi-subagents`).
+ * - Uses `require.resolve('pi-subagents')` to check installation.
+ * - If not installed, prompts the user to install via `pi install pi-subagents`.
+ * - If the user declines or installation fails, returns false (caller disables the extension).
  *
- * @returns true if installed or successfully installed
- * @throws  if the user declines or installation fails
+ * @returns true if installed or successfully installed; false otherwise
  */
 async function checkDependencies(prompt) {
-    // Try to resolve pi-subagents to verify it's installed
-    if (isSubagentsInstalled()) {
+    // Already installed — nothing to do
+    try {
+        require.resolve("pi-subagents");
         return true;
     }
+    catch {
+        // MODULE_NOT_FOUND — prompt the user
+    }
     console.warn("[pi-read-delegator] ⚠️ pi-subagents is not installed.");
-    const answer = await prompt("⚠️ pi-subagents is not installed. Install it now? [Y/n]");
+    const answer = await prompt("pi-subagents is not installed. Install it now? [Y/n]");
     const normalized = answer.trim().toLowerCase();
     if (normalized !== "" && normalized !== "y" && normalized !== "yes") {
-        throw new Error("pi-subagents is required. Please install it manually: pi install pi-subagents");
+        console.error("[pi-read-delegator] ❌ Cannot proceed without pi-subagents. Extension disabled.");
+        return false;
     }
     // Attempt installation
     console.log("[pi-read-delegator] 📦 Installing pi-subagents…");
     try {
-        // Try `pi install pi-subagents` first (the Pi package manager)
         (0, child_process_1.execSync)("pi install pi-subagents", {
             stdio: "pipe",
             timeout: 60_000,
@@ -105,7 +109,7 @@ async function checkDependencies(prompt) {
         });
         console.log("[pi-read-delegator] ✅ pi-subagents installed via pi.");
     }
-    catch {
+    catch (firstErr) {
         // Fallback to global npm install
         try {
             (0, child_process_1.execSync)("npm install -g pi-subagents", {
@@ -115,24 +119,28 @@ async function checkDependencies(prompt) {
             });
             console.log("[pi-read-delegator] ✅ pi-subagents installed via npm.");
         }
-        catch (err) {
-            throw new Error("❌ Installation failed. Please install manually: npm install -g pi-subagents");
+        catch (secondErr) {
+            console.error("[pi-read-delegator] ❌ Cannot proceed without pi-subagents. Extension disabled.");
+            return false;
         }
     }
     // Verify installation took effect
-    if (!isSubagentsInstalled()) {
-        throw new Error("❌ pi-subagents installed but cannot be found. Restart Pi and try again.");
+    try {
+        require.resolve("pi-subagents");
+        return true;
+    }
+    catch {
+        console.error("[pi-read-delegator] ❌ pi-subagents installed but cannot be found. Restart Pi and try again.");
+        return false;
     }
-    return true;
 }
 /**
- * Simple check: can we require/import pi-subagents?
+ * Quick synchronous check: can we resolve pi-subagents?
  */
 function isSubagentsInstalled() {
     try {
-        // Dynamic require that works even if TypeScript doesn't know the module
-        const mod = require("pi-subagents");
-        return mod !== undefined;
+        require.resolve("pi-subagents");
+        return true;
     }
     catch {
         return false;

package/ui.d.ts

@@ -4,7 +4,7 @@
  * Detects the user's language preference (config → Pi settings → OS → "en")
  * and provides localized messages. Manages a status bar indicator.
  */
-export type Status = "active" | "idle" | "error";
+export type Status = "active" | "idle" | "error" | "off";
 /** Minimal Pi agent interface for the status bar API. */
 export interface AgentWithStatusBar {
     /** Set text to display in the Pi status bar. */

package/ui.js

@@ -84,17 +84,25 @@ const messages = {
         tr: "❌ Kurulum başarısız. Elle yükleyin.",
         en: "❌ Installation failed. Install manually.",
     },
+    deps_disabled: {
+        tr: "pi-subagents olmadan devam edilemez. Eklenti devre dışı.",
+        en: "Cannot proceed without pi-subagents. Extension disabled.",
+    },
     status_active: {
-        tr: "● aktif",
-        en: "● active",
+        tr: "🟢 reader",
+        en: "🟢 reader",
     },
     status_idle: {
-        tr: "○ boşta",
-        en: "○ idle",
+        tr: "○ reader",
+        en: "○ reader",
     },
     status_error: {
-        tr: "⚠ hata",
-        en: "⚠ error",
+        tr: "⚠ reader",
+        en: "⚠ reader",
+    },
+    status_off: {
+        tr: "🔴 reader",
+        en: "🔴 reader",
     },
     blocked: {
         tr: "🚫 Engellendi: ",
@@ -217,12 +225,15 @@ function updateStatusBar(status) {
         case "error":
             text = msg("status_error");
             break;
+        case "off":
+            text = msg("status_off");
+            break;
         default:
             text = msg("status_idle");
             break;
     }
     try {
-        statusBarAgent.setStatusBarText(`pi-read-delegator: ${text}`);
+        statusBarAgent.setStatusBarText(text);
     }
     catch {
         // Graceful fallback — not all Pi versions support status bar