@stfade/pi-read-delegator 1.0.11 → 1.0.13

package/{tool-blocker.js → dist/tool-blocker.js}

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * tool-blocker.ts — Tool removal and restoration for pi-read-delegator
  *
@@ -9,13 +8,7 @@
  *
  * We store removed tool definitions in a Map so they can be restored later.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.blockTools = blockTools;
-exports.restoreTools = restoreTools;
-exports.tempAllowOnce = tempAllowOnce;
-exports.isBlocked = isBlocked;
-exports.getBlockedTools = getBlockedTools;
-exports.reset = reset;
+import { rawLog, rawError } from "./ui";
 // ---------------------------------------------------------------------------
 // Tool blocker state
 // ---------------------------------------------------------------------------
@@ -29,7 +22,7 @@ const removedTools = new Map();
  * Saves their definitions so they can be restored later.
  * If a tool is already removed, it is silently skipped.
  */
-function blockTools(agent, tools) {
+export function blockTools(agent, tools) {
     const currentTools = agent.getTools();
     for (const toolName of tools) {
         // Skip if already removed
@@ -40,10 +33,10 @@ function blockTools(agent, tools) {
             removedTools.set(toolName, definition);
             try {
                 agent.removeTool(toolName);
-                console.log(`[pi-read-delegator] Blocked tool: ${toolName}`);
+                rawLog(`Blocked tool: ${toolName}`);
             }
             catch (err) {
-                console.error(`[pi-read-delegator] Failed to block tool "${toolName}": ${err}`);
+                rawError(`Failed to block tool "${toolName}": ${err}`);
             }
         }
     }
@@ -52,14 +45,14 @@ function blockTools(agent, tools) {
  * Restore all previously blocked tools to the agent.
  * If a tool was never removed, it is skipped.
  */
-function restoreTools(agent) {
+export function restoreTools(agent) {
     for (const [toolName, definition] of removedTools.entries()) {
         try {
             agent.addTool(definition);
-            console.log(`[pi-read-delegator] Restored tool: ${toolName}`);
+            rawLog(`Restored tool: ${toolName}`);
         }
         catch (err) {
-            console.error(`[pi-read-delegator] Failed to restore tool "${toolName}": ${err}`);
+            rawError(`Failed to restore tool "${toolName}": ${err}`);
         }
     }
     removedTools.clear();
@@ -76,7 +69,7 @@ function restoreTools(agent) {
  * @param callback     Async function to run while tools are available
  * @returns The callback's return value
  */
-async function tempAllowOnce(agent, blockedTools, callback) {
+export async function tempAllowOnce(agent, blockedTools, callback) {
     // Restore temporarily
     const restoredNow = [];
     // We need to get the definitions from our map, but they might not be there
@@ -92,7 +85,7 @@ async function tempAllowOnce(agent, blockedTools, callback) {
                 restoredNow.push(toolName);
             }
             catch (err) {
-                console.error(`[pi-read-delegator] Failed to temporarily restore "${toolName}": ${err}`);
+                rawError(`Failed to temporarily restore "${toolName}": ${err}`);
             }
         }
     }
@@ -113,7 +106,7 @@ async function tempAllowOnce(agent, blockedTools, callback) {
                     agent.removeTool(toolName);
                 }
                 catch (err) {
-                    console.error(`[pi-read-delegator] Failed to re-block "${toolName}": ${err}`);
+                    rawError(`Failed to re-block "${toolName}": ${err}`);
                 }
             }
         }
@@ -122,19 +115,19 @@ async function tempAllowOnce(agent, blockedTools, callback) {
 /**
  * Check whether a given tool is currently blocked.
  */
-function isBlocked(toolName) {
+export function isBlocked(toolName) {
     return removedTools.has(toolName);
 }
 /**
  * Get the list of currently blocked tool names.
  */
-function getBlockedTools() {
+export function getBlockedTools() {
     return Array.from(removedTools.keys());
 }
 /**
  * Clear all blocked tool state (useful for testing / full reset).
  */
-function reset() {
+export function reset() {
     removedTools.clear();
 }
 //# sourceMappingURL=tool-blocker.js.map

package/{ui.js → dist/ui.js}

@@ -1,59 +1,12 @@
-"use strict";
 /**
  * ui.ts — Localization, status bar, and logging for pi-read-delegator
  *
  * Detects the user's language preference (config → Pi settings → OS → "en")
  * and provides localized messages. Manages a status bar indicator.
  */
-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]; } };
-    }
-    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.getLanguage = getLanguage;
-exports.msg = msg;
-exports.setLanguage = setLanguage;
-exports.initStatusBar = initStatusBar;
-exports.updateStatusBar = updateStatusBar;
-exports.getStatus = getStatus;
-exports.log = log;
-exports.logError = logError;
-exports.logWarn = logWarn;
-exports.rawLog = rawLog;
-exports.rawWarn = rawWarn;
-exports.rawError = rawError;
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
 // ---------------------------------------------------------------------------
 // Language detection
 // ---------------------------------------------------------------------------
@@ -146,7 +99,7 @@ let currentLang = "en";
  * 3. Operating system locale (first two chars)
  * 4. Fallback "en"
  */
-function getLanguage(configLang) {
+export function getLanguage(configLang) {
     // 1. Explicit config override
     if (configLang && configLang !== "auto") {
         currentLang = configLang;
@@ -188,7 +141,7 @@ function getLanguage(configLang) {
  *
  * Falls back to English if the current language doesn't have the key.
  */
-function msg(key, lang) {
+export function msg(key, lang) {
     const langCode = lang ?? currentLang;
     const entry = messages[key];
     if (!entry)
@@ -198,7 +151,7 @@ function msg(key, lang) {
 /**
  * Explicitly set the current language (for /read-delegator lang <code>).
  */
-function setLanguage(lang) {
+export function setLanguage(lang) {
     currentLang = lang;
 }
 // ---------------------------------------------------------------------------
@@ -209,14 +162,14 @@ let currentStatus = "idle";
 /**
  * Initialize the status bar with the given agent.
  */
-function initStatusBar(agent) {
+export function initStatusBar(agent) {
     statusBarAgent = agent;
     updateStatusBar("idle");
 }
 /**
  * Update the status bar indicator.
  */
-function updateStatusBar(status) {
+export function updateStatusBar(status) {
     currentStatus = status;
     if (!statusBarAgent)
         return;
@@ -245,7 +198,7 @@ function updateStatusBar(status) {
 /**
  * Get the current status.
  */
-function getStatus() {
+export function getStatus() {
     return currentStatus;
 }
 // ---------------------------------------------------------------------------
@@ -256,7 +209,7 @@ function getStatus() {
  *
  * Prepend "[pi-read-delegator]" for easy filtering.
  */
-function log(key, detail) {
+export function log(key, detail) {
     const prefix = "[pi-read-delegator]";
     const message = msg(key);
     if (detail) {
@@ -269,7 +222,7 @@ function log(key, detail) {
 /**
  * Log an error with the standard prefix.
  */
-function logError(key, detail) {
+export function logError(key, detail) {
     const prefix = "[pi-read-delegator]";
     const message = msg(key);
     const full = detail ? `${message}${detail}` : message;
@@ -278,7 +231,7 @@ function logError(key, detail) {
 /**
  * Log a warning with the standard prefix.
  */
-function logWarn(key, detail) {
+export function logWarn(key, detail) {
     const prefix = "[pi-read-delegator]";
     const message = msg(key);
     const full = detail ? `${message}${detail}` : message;
@@ -287,13 +240,13 @@ function logWarn(key, detail) {
 // Raw logging — bypass i18n lookup for extension-internal messages.
 // These are the single source of console.* calls; everywhere else routes
 // through these helpers so pi-lens console-statement checks pass cleanly.
-function rawLog(message) {
+export function rawLog(message) {
     console.log(`[pi-read-delegator] ${message}`);
 }
-function rawWarn(message) {
+export function rawWarn(message) {
     console.warn(`[pi-read-delegator] ${message}`);
 }
-function rawError(message) {
+export function rawError(message) {
     console.error(`[pi-read-delegator] ${message}`);
 }
 //# sourceMappingURL=ui.js.map

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "@stfade/pi-read-delegator",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "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",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "pi-extension": true,
   "files": [
-    "index.js",
-    "index.d.ts",
-    "config.js",
-    "config.d.ts",
-    "tool-blocker.js",
-    "tool-blocker.d.ts",
-    "bash-filter.js",
-    "bash-filter.d.ts",
-    "reader-manager.js",
-    "reader-manager.d.ts",
-    "ui.js",
-    "ui.d.ts",
-    "templates/reader.md"
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/config.js",
+    "dist/config.d.ts",
+    "dist/tool-blocker.js",
+    "dist/tool-blocker.d.ts",
+    "dist/bash-filter.js",
+    "dist/bash-filter.d.ts",
+    "dist/reader-manager.js",
+    "dist/reader-manager.d.ts",
+    "dist/ui.js",
+    "dist/ui.d.ts",
+    "dist/templates/reader.md"
   ],
   "scripts": {
     "build": "tsc",
@@ -34,6 +34,7 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.79.3",
     "@types/node": "^20.0.0",
     "typescript": "^5.4.0"
   },
@@ -44,6 +45,8 @@
     "node": ">=18"
   },
   "pi": {
-    "extensions": ["./index.js"]
+    "extensions": [
+      "dist/index.js"
+    ]
   }
 }

package/bash-filter.js

@@ -1,242 +0,0 @@
-"use strict";
-/**
- * bash-filter.ts — Bash command classification and Reader forwarding
- *
- * Classifies shell commands as read-only (delegate to Reader subagent),
- * write (execute directly), or ambiguous (prompt user).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReadCommand = isReadCommand;
-exports.isWriteCommand = isWriteCommand;
-exports.wrapForReader = wrapForReader;
-exports.wrapTaskForReader = wrapTaskForReader;
-// ---------------------------------------------------------------------------
-// Command lists
-// ---------------------------------------------------------------------------
-/**
- * Commands that ONLY read and should be forwarded to the Reader subagent.
- * - sed without -i is read-only (stream editor writing to stdout).
- * - awk is read-only (pattern scanning and processing language).
- */
-const READ_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",
-]);
-/**
- * Commands that write to the filesystem and should execute directly.
- * sed and tee are context-dependent — handled specially in isWriteCommand.
- */
-const WRITE_COMMANDS = new Set([
-    "mkdir",
-    "touch",
-    "echo",
-    "rm",
-    "mv",
-    "cp",
-    "chmod",
-    "chown",
-    "ln",
-    "rmdir",
-    "npm",
-    "pnpm",
-    "yarn",
-    "pip",
-    "cargo",
-    "go",
-    "npx",
-    "node",
-    "python",
-    "python3",
-    "git",
-    "docker",
-    "kubectl",
-    "tsc",
-    "make",
-    "cmake",
-    "dotnet",
-    "rustc",
-    "gcc",
-    "g++",
-]);
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Determine if a bash command is read-only and should be forwarded to Reader.
- *
- * Rules:
- * - If the first word is in READ_COMMANDS → true
- * - sed without -i flag → true (read-only stream edit)
- * - sed with -i → false (in-place edit = write)
- */
-function isReadCommand(command) {
-    const argv = parseArgv(command);
-    if (argv.length === 0)
-        return false;
-    const cmd = argv[0].toLowerCase();
-    // sed is special: if -i is present, it's a write; otherwise read-only
-    if (cmd === "sed" || cmd === "sed.exe") {
-        return !hasInlineFlag(argv);
-    }
-    return READ_COMMANDS.has(cmd);
-}
-/**
- * Determine if a bash command modifies the filesystem and should run directly.
- *
- * Rules:
- * - If the first word is in WRITE_COMMANDS → true
- * - sed with -i flag → true (in-place edit)
- * - Command contains > or >> redirect → true (writes to file)
- * - Command contains tee without -a flag → true (writes to file)
- */
-function isWriteCommand(command) {
-    const argv = parseArgv(command);
-    if (argv.length === 0)
-        return false;
-    const cmd = argv[0].toLowerCase();
-    // sed with -i = write
-    if (cmd === "sed" || cmd === "sed.exe") {
-        return hasInlineFlag(argv);
-    }
-    if (WRITE_COMMANDS.has(cmd))
-        return true;
-    // Check for output redirection markers (> or >>)
-    // We do a simple string match outside the parsed argv because parseArgv
-    // might stop at the redirect operator.
-    if (/\b>>?\b/.test(command))
-        return true;
-    // tee is ambiguous: if -a (append) it's write, otherwise also write
-    if (cmd === "tee" || cmd === "tee.exe")
-        return true;
-    return false;
-}
-/**
- * Wrap a shell command into a Reader subagent task.
- *
- * Returns a formatted string instructing the Reader to execute and report
- * minimal results.
- */
-function wrapForReader(command) {
-    return [
-        "Execute this shell command and return ONLY the essential result.",
-        "Max 5 lines or a single number. Never dump full file contents.",
-        `Command: ${command}`,
-    ].join("\n");
-}
-/**
- * Wrap a generic task (non-bash) into a Reader subagent task.
- */
-function wrapTaskForReader(task) {
-    return [
-        "Execute this task and return ONLY the essential result.",
-        "Max 5 lines or a single number. Never dump full file contents.",
-        `Task: ${task}`,
-    ].join("\n");
-}
-// ---------------------------------------------------------------------------
-// Internals
-// ---------------------------------------------------------------------------
-/**
- * Parse a command string into argv tokens, respecting single/double quotes.
- *
- * This is a simplified parser — edge cases like escaped quotes inside
- * opposite-quoted strings are handled on a best-effort basis.
- */
-function parseArgv(command) {
-    const tokens = [];
-    let current = "";
-    let inSingle = false;
-    let inDouble = false;
-    for (let i = 0; i < command.length; i++) {
-        const ch = command[i];
-        if (inSingle) {
-            if (ch === "'") {
-                inSingle = false;
-            }
-            else {
-                current += ch;
-            }
-        }
-        else if (inDouble) {
-            if (ch === '"') {
-                inDouble = false;
-            }
-            else if (ch === "\\" && i + 1 < command.length) {
-                // Simple escape handling inside double quotes
-                const next = command[i + 1];
-                if (next === '"' || next === "\\" || next === "$" || next === "`") {
-                    current += next;
-                    i++;
-                }
-                else {
-                    current += ch;
-                }
-            }
-            else {
-                current += ch;
-            }
-        }
-        else {
-            if (ch === "'") {
-                inSingle = true;
-            }
-            else if (ch === '"') {
-                inDouble = true;
-            }
-            else if (ch === " " || ch === "\t") {
-                if (current.length > 0) {
-                    tokens.push(current);
-                    current = "";
-                }
-            }
-            else {
-                current += ch;
-            }
-        }
-    }
-    // Flush remaining token
-    if (current.length > 0) {
-        tokens.push(current);
-    }
-    return tokens;
-}
-/**
- * Check whether `sed` has the -i (in-place) flag.
- */
-function hasInlineFlag(argv) {
-    for (let i = 1; i < argv.length; i++) {
-        const arg = argv[i];
-        // -i, -i.bak, --in-place, --in-place=.bak
-        if (arg === "-i" || arg.startsWith("-i.") || arg === "--in-place") {
-            return true;
-        }
-        if (arg.startsWith("--in-place=")) {
-            return true;
-        }
-        // Stop at the expression (s/.../.../ or -e '...') — flags after that
-        // might apply to the expression, not sed itself. In practice, -i always
-        // comes before the expression.
-    }
-    return false;
-}
-//# sourceMappingURL=bash-filter.js.map