@stfade/pi-read-delegator 1.0.0

package/tool-blocker.d.ts

@@ -0,0 +1,59 @@
+/**
+ * tool-blocker.ts — Tool removal and restoration for pi-read-delegator
+ *
+ * Pi's Extension API exposes:
+ *   agent.getTools()          → ToolDefinition[]
+ *   agent.removeTool(name)    → void
+ *   agent.addTool(definition)  → void
+ *
+ * We store removed tool definitions in a Map so they can be restored later.
+ */
+/** Minimal shape for a Pi tool definition. */
+export interface ToolDefinition {
+    name: string;
+    description?: string;
+    [key: string]: unknown;
+}
+/** The Pi agent interface this module operates on. */
+export interface ExtensionAgent {
+    getTools(): ToolDefinition[];
+    removeTool(name: string): void;
+    addTool(definition: ToolDefinition): void;
+}
+/**
+ * Remove the listed tools from the agent.
+ * Saves their definitions so they can be restored later.
+ * If a tool is already removed, it is silently skipped.
+ */
+export declare function blockTools(agent: ExtensionAgent, tools: string[]): void;
+/**
+ * Restore all previously blocked tools to the agent.
+ * If a tool was never removed, it is skipped.
+ */
+export declare function restoreTools(agent: ExtensionAgent): void;
+/**
+ * Temporarily allow the main model to use blocked tools for one operation.
+ *
+ * 1. Restore the tools
+ * 2. Await the callback (which performs the read)
+ * 3. Re-block the tools
+ *
+ * @param agent        The Pi agent
+ * @param blockedTools List of tool names that should stay blocked normally
+ * @param callback     Async function to run while tools are available
+ * @returns The callback's return value
+ */
+export declare function tempAllowOnce<T>(agent: ExtensionAgent, blockedTools: string[], callback: () => Promise<T>): Promise<T>;
+/**
+ * Check whether a given tool is currently blocked.
+ */
+export declare function isBlocked(toolName: string): boolean;
+/**
+ * Get the list of currently blocked tool names.
+ */
+export declare function getBlockedTools(): string[];
+/**
+ * Clear all blocked tool state (useful for testing / full reset).
+ */
+export declare function reset(): void;
+//# sourceMappingURL=tool-blocker.d.ts.map

package/tool-blocker.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * tool-blocker.ts — Tool removal and restoration for pi-read-delegator
+ *
+ * Pi's Extension API exposes:
+ *   agent.getTools()          → ToolDefinition[]
+ *   agent.removeTool(name)    → void
+ *   agent.addTool(definition)  → void
+ *
+ * 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;
+// ---------------------------------------------------------------------------
+// Tool blocker state
+// ---------------------------------------------------------------------------
+/** Stores tool definitions that were removed, keyed by tool name. */
+const removedTools = new Map();
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Remove the listed tools from the agent.
+ * Saves their definitions so they can be restored later.
+ * If a tool is already removed, it is silently skipped.
+ */
+function blockTools(agent, tools) {
+    const currentTools = agent.getTools();
+    for (const toolName of tools) {
+        // Skip if already removed
+        if (removedTools.has(toolName))
+            continue;
+        const definition = currentTools.find((t) => t.name === toolName);
+        if (definition) {
+            removedTools.set(toolName, definition);
+            try {
+                agent.removeTool(toolName);
+                console.log(`[pi-read-delegator] Blocked tool: ${toolName}`);
+            }
+            catch (err) {
+                console.error(`[pi-read-delegator] Failed to block tool "${toolName}": ${err}`);
+            }
+        }
+    }
+}
+/**
+ * Restore all previously blocked tools to the agent.
+ * If a tool was never removed, it is skipped.
+ */
+function restoreTools(agent) {
+    for (const [toolName, definition] of removedTools.entries()) {
+        try {
+            agent.addTool(definition);
+            console.log(`[pi-read-delegator] Restored tool: ${toolName}`);
+        }
+        catch (err) {
+            console.error(`[pi-read-delegator] Failed to restore tool "${toolName}": ${err}`);
+        }
+    }
+    removedTools.clear();
+}
+/**
+ * Temporarily allow the main model to use blocked tools for one operation.
+ *
+ * 1. Restore the tools
+ * 2. Await the callback (which performs the read)
+ * 3. Re-block the tools
+ *
+ * @param agent        The Pi agent
+ * @param blockedTools List of tool names that should stay blocked normally
+ * @param callback     Async function to run while tools are available
+ * @returns The callback's return value
+ */
+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
+    // if the tools were never initially blocked. In that case, we just re-block
+    // the names after.
+    for (const toolName of blockedTools) {
+        const definition = removedTools.get(toolName);
+        if (definition) {
+            try {
+                agent.addTool(definition);
+                // Remove from the map temporarily so restoreTools doesn't double-restore
+                removedTools.delete(toolName);
+                restoredNow.push(toolName);
+            }
+            catch (err) {
+                console.error(`[pi-read-delegator] Failed to temporarily restore "${toolName}": ${err}`);
+            }
+        }
+    }
+    try {
+        // Run the callback while tools are available
+        const result = await callback();
+        return result;
+    }
+    finally {
+        // Re-block the tools we restored
+        for (const toolName of restoredNow) {
+            // Find the definition from agent's current tool list before removing
+            const currentTools = agent.getTools();
+            const definition = currentTools.find((t) => t.name === toolName);
+            if (definition) {
+                removedTools.set(toolName, definition);
+                try {
+                    agent.removeTool(toolName);
+                }
+                catch (err) {
+                    console.error(`[pi-read-delegator] Failed to re-block "${toolName}": ${err}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Check whether a given tool is currently blocked.
+ */
+function isBlocked(toolName) {
+    return removedTools.has(toolName);
+}
+/**
+ * Get the list of currently blocked tool names.
+ */
+function getBlockedTools() {
+    return Array.from(removedTools.keys());
+}
+/**
+ * Clear all blocked tool state (useful for testing / full reset).
+ */
+function reset() {
+    removedTools.clear();
+}
+//# sourceMappingURL=tool-blocker.js.map

package/ui.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+export type Status = "active" | "idle" | "error";
+/** Minimal Pi agent interface for the status bar API. */
+export interface AgentWithStatusBar {
+    /** Set text to display in the Pi status bar. */
+    setStatusBarText(text: string): void;
+}
+/**
+ * Resolve the effective language.
+ *
+ * Priority:
+ * 1. Explicit language in config (if not "auto")
+ * 2. Pi's own language setting from ~/.pi/settings.json
+ * 3. Operating system locale (first two chars)
+ * 4. Fallback "en"
+ */
+export declare function getLanguage(configLang?: string): string;
+/**
+ * Retrieve a localized message by key.
+ *
+ * Falls back to English if the current language doesn't have the key.
+ */
+export declare function msg(key: string, lang?: string): string;
+/**
+ * Explicitly set the current language (for /read-delegator lang <code>).
+ */
+export declare function setLanguage(lang: string): void;
+/**
+ * Initialize the status bar with the given agent.
+ */
+export declare function initStatusBar(agent: AgentWithStatusBar): void;
+/**
+ * Update the status bar indicator.
+ */
+export declare function updateStatusBar(status: Status): void;
+/**
+ * Get the current status.
+ */
+export declare function getStatus(): Status;
+/**
+ * Log a one-line Reader event using the current language.
+ *
+ * Prepend "[pi-read-delegator]" for easy filtering.
+ */
+export declare function log(key: string, detail?: string): void;
+/**
+ * Log an error with the standard prefix.
+ */
+export declare function logError(key: string, detail?: string): void;
+/**
+ * Log a warning with the standard prefix.
+ */
+export declare function logWarn(key: string, detail?: string): void;
+//# sourceMappingURL=ui.d.ts.map

package/ui.js

@@ -0,0 +1,273 @@
+"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;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// ---------------------------------------------------------------------------
+// Language detection
+// ---------------------------------------------------------------------------
+/**
+ * Language map of all translatable messages.
+ *
+ * Adding a new language means adding a record for every key.
+ */
+const messages = {
+    reader_calling: {
+        tr: "🔍 Reader: sorgu çalıştırılıyor…",
+        en: "🔍 Reader: executing query…",
+    },
+    reader_done: {
+        tr: "✅ Reader: tamamlandı",
+        en: "✅ Reader: done",
+    },
+    reader_failed: {
+        tr: "❌ Reader: başarısız - ",
+        en: "❌ Reader: failed - ",
+    },
+    deps_missing: {
+        tr: "⚠️ pi-subagents yüklü değil. Yüklensin mi? [E/h]",
+        en: "⚠️ pi-subagents not installed. Install now? [Y/n]",
+    },
+    deps_installing: {
+        tr: "📦 pi-subagents yükleniyor…",
+        en: "📦 Installing pi-subagents…",
+    },
+    deps_failed: {
+        tr: "❌ Kurulum başarısız. Elle yükleyin.",
+        en: "❌ Installation failed. Install manually.",
+    },
+    status_active: {
+        tr: "● aktif",
+        en: "● active",
+    },
+    status_idle: {
+        tr: "○ boşta",
+        en: "○ idle",
+    },
+    status_error: {
+        tr: "⚠ hata",
+        en: "⚠ error",
+    },
+    blocked: {
+        tr: "🚫 Engellendi: ",
+        en: "🚫 Blocked: ",
+    },
+    already_blocked: {
+        tr: "⚠ Araçlar zaten engellenmiş.",
+        en: "⚠ Tools are already blocked.",
+    },
+    already_enabled: {
+        tr: "⚠ Araçlar zaten aktif.",
+        en: "⚠ Tools are already active.",
+    },
+    enabled: {
+        tr: "✅ pi-read-delegator etkin",
+        en: "✅ pi-read-delegator enabled",
+    },
+    disabled: {
+        tr: "🔓 pi-read-delegator devre dışı — tüm araçlar serbest",
+        en: "🔓 pi-read-delegator disabled — all tools free",
+    },
+    config_saved: {
+        tr: "💾 Konfigürasyon kaydedildi",
+        en: "💾 Configuration saved",
+    },
+};
+// Cached language code determined at init time.
+let currentLang = "en";
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the effective language.
+ *
+ * Priority:
+ * 1. Explicit language in config (if not "auto")
+ * 2. Pi's own language setting from ~/.pi/settings.json
+ * 3. Operating system locale (first two chars)
+ * 4. Fallback "en"
+ */
+function getLanguage(configLang) {
+    // 1. Explicit config override
+    if (configLang && configLang !== "auto") {
+        currentLang = configLang;
+        return currentLang;
+    }
+    // 2. Pi's own setting
+    try {
+        const piSettingsPath = path.join(os.homedir(), ".pi", "settings.json");
+        if (fs.existsSync(piSettingsPath)) {
+            const raw = fs.readFileSync(piSettingsPath, "utf-8");
+            const settings = JSON.parse(raw);
+            if (typeof settings.language === "string") {
+                currentLang = settings.language;
+                return currentLang;
+            }
+        }
+    }
+    catch {
+        // Silently fall through
+    }
+    // 3. OS locale (e.g., "tr-TR" → "tr")
+    try {
+        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+        const short = locale.split("-")[0];
+        if (short && short.length === 2 && messages.reader_calling[short]) {
+            currentLang = short;
+            return currentLang;
+        }
+    }
+    catch {
+        // Silently fall through
+    }
+    // 4. Fallback
+    currentLang = "en";
+    return currentLang;
+}
+/**
+ * Retrieve a localized message by key.
+ *
+ * Falls back to English if the current language doesn't have the key.
+ */
+function msg(key, lang) {
+    const langCode = lang ?? currentLang;
+    const entry = messages[key];
+    if (!entry)
+        return `??? ${key} ???`;
+    return entry[langCode] ?? entry.en ?? key;
+}
+/**
+ * Explicitly set the current language (for /read-delegator lang <code>).
+ */
+function setLanguage(lang) {
+    currentLang = lang;
+}
+// ---------------------------------------------------------------------------
+// Status bar
+// ---------------------------------------------------------------------------
+let statusBarAgent = null;
+let currentStatus = "idle";
+/**
+ * Initialize the status bar with the given agent.
+ */
+function initStatusBar(agent) {
+    statusBarAgent = agent;
+    updateStatusBar("idle");
+}
+/**
+ * Update the status bar indicator.
+ */
+function updateStatusBar(status) {
+    currentStatus = status;
+    if (!statusBarAgent)
+        return;
+    let text;
+    switch (status) {
+        case "active":
+            text = msg("status_active");
+            break;
+        case "error":
+            text = msg("status_error");
+            break;
+        default:
+            text = msg("status_idle");
+            break;
+    }
+    try {
+        statusBarAgent.setStatusBarText(`pi-read-delegator: ${text}`);
+    }
+    catch {
+        // Graceful fallback — not all Pi versions support status bar
+    }
+}
+/**
+ * Get the current status.
+ */
+function getStatus() {
+    return currentStatus;
+}
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+/**
+ * Log a one-line Reader event using the current language.
+ *
+ * Prepend "[pi-read-delegator]" for easy filtering.
+ */
+function log(key, detail) {
+    const prefix = "[pi-read-delegator]";
+    const message = msg(key);
+    if (detail) {
+        console.log(`${prefix} ${message}${detail}`);
+    }
+    else {
+        console.log(`${prefix} ${message}`);
+    }
+}
+/**
+ * Log an error with the standard prefix.
+ */
+function logError(key, detail) {
+    const prefix = "[pi-read-delegator]";
+    const message = msg(key);
+    const full = detail ? `${message}${detail}` : message;
+    console.error(`${prefix} ${full}`);
+}
+/**
+ * Log a warning with the standard prefix.
+ */
+function logWarn(key, detail) {
+    const prefix = "[pi-read-delegator]";
+    const message = msg(key);
+    const full = detail ? `${message}${detail}` : message;
+    console.warn(`${prefix} ${full}`);
+}
+//# sourceMappingURL=ui.js.map