@krtclcdy/tersio 1.0.1 → 1.0.2

package/extensions/combo-toggle/index.js

@@ -0,0 +1,157 @@
+// /combo session toggle — set all three (caveman, rtk, ponytail) at once.
+// Modes: off | medium | balanced | max
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { COMBO_LEVELS, getSharedComboState, isOmpSubagentPrompt, normalizeComboLevel, reconcileSharedComboEntries, setSharedComboLevel, setSharedComboListener, } from "../shared/session-state.js";
+import { readComboDefault } from "../shared/plugin-settings.js";
+const require = createRequire(import.meta.url);
+function ponytailFallback(mode) {
+    const intensity = mode === "lite"
+        ? "Prefer the simplest correct solution."
+        : mode === "review"
+            ? "Review only for avoidable complexity; recommend the smallest correct replacement."
+            : "Use the minimum correct solution. Delete or reuse before adding.";
+    return `🦥 PONYTAIL MODE ACTIVE — level: ${mode}\n${intensity} Understand the path first and fix root causes, not symptoms. Prefer the standard library and YAGNI. Avoid speculative abstractions and dependencies. Preserve correctness. Verify changed behavior.`;
+}
+function entriesFrom(ctx) {
+    return ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+}
+function levelSummary(state) {
+    return `caveman=${state.caveman} rtk=${state.rtk} ponytail=${state.ponytail}`;
+}
+function hasPonytailInstructions(systemPrompt) {
+    const prompts = Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+    return prompts.some((prompt) => typeof prompt === "string" && prompt.includes("PONYTAIL MODE ACTIVE"));
+}
+function loadPonytailInstructions(mode) {
+    try {
+        const installed = path.join(os.homedir(), ".omp", "plugins", "node_modules", "@dietrichgebert", "ponytail", "hooks", "ponytail-instructions.js");
+        const { getPonytailInstructions } = require(installed);
+        if (typeof getPonytailInstructions === "function")
+            return getPonytailInstructions(mode);
+    }
+    catch { }
+    return ponytailFallback(mode);
+}
+export default function comboToggleExtension(pi) {
+    pi.setLabel?.("Combo session toggle (all 3 add-ons)");
+    let currentState = getSharedComboState();
+    let lastCtx = undefined;
+    function syncStatus(ctx) {
+        if (ctx)
+            lastCtx = ctx;
+        const c = ctx || lastCtx;
+        if (!c?.ui?.setStatus)
+            return;
+        // Single unified bar replaces the three per-extension bars while a preset is
+        // active. In custom/off, the individual bars come back and combo stays clear.
+        if (currentState.level !== "medium" && currentState.level !== "balanced" && currentState.level !== "max") {
+            c.ui.setStatus("combo", undefined);
+            return;
+        }
+        const theme = c.ui.theme;
+        const c0 = currentState.caveman.toUpperCase();
+        const r = currentState.rtk.toUpperCase();
+        const p = currentState.ponytail.toUpperCase();
+        const lvl = currentState.level.toUpperCase();
+        const label = `combo ${lvl}: 🪨caveman=${c0} ⚡rtk=${r} 🦥ponytail=${p}`;
+        c.ui.setStatus("combo", theme?.fg ? `${theme.fg("accent", "🧩")} ${theme.fg("muted", label)}` : `🧩 ${label}`);
+        // Clobber any sibling bars another extension may have painted in a race
+        // during session_start — our bar is canonical for the duration of the preset.
+        c.ui.setStatus("caveman", undefined);
+        c.ui.setStatus("rtk", undefined);
+        c.ui.setStatus("ponytail", undefined);
+    }
+    function useState(state, ctx) {
+        currentState = state;
+        syncStatus(ctx);
+        return state;
+    }
+    function reconcile(ctx) {
+        if (!ctx?.hasUI)
+            return currentState;
+        return useState(reconcileSharedComboEntries(entriesFrom(ctx)), ctx);
+    }
+    function listen(ctx) {
+        if (ctx?.hasUI)
+            setSharedComboListener((state) => useState(state));
+    }
+    pi.registerCommand?.("combo", {
+        description: "Toggle all 3 OMP add-ons at once. Usage: /combo <off|medium|balanced|max|status>",
+        handler: async (args, ctx) => {
+            listen(ctx);
+            const arg = String(args || "").trim().toLowerCase();
+            if (!arg || arg === "status") {
+                const state = reconcile(ctx);
+                ctx?.ui?.notify?.(`Combo: ${state.level === "custom" ? "INACTIVE" : state.level.toUpperCase()} (${levelSummary(state)})`, "info");
+                return;
+            }
+            if (arg === "help") {
+                ctx?.ui?.notify?.("/combo off      — disables all 3 (caveman, rtk, ponytail)\n" +
+                    "/combo medium   — light: caveman=lite, rtk=on, ponytail=lite\n" +
+                    "/combo balanced — middle: caveman=full, rtk=on, ponytail=full\n" +
+                    "/combo max      — aggressive: caveman=ultra, rtk=on, ponytail=ultra", "info");
+                return;
+            }
+            const level = normalizeComboLevel(arg);
+            if (!level) {
+                ctx?.ui?.notify?.(`Unknown combo level: ${arg}. Use: off | medium | balanced | max`, "warning");
+                return;
+            }
+            const modes = COMBO_LEVELS[level];
+            // Persist per-extension state so they restore on session_start
+            pi.appendEntry?.("caveman-mode", { mode: modes.caveman });
+            pi.appendEntry?.("rtk-mode", { enabled: modes.rtk === "on" });
+            pi.appendEntry?.("ponytail-mode", { mode: modes.ponytail });
+            pi.appendEntry?.("combo-level", { level });
+            useState(setSharedComboLevel(level), ctx);
+            ctx?.ui?.notify?.(`Combo ${level} applied: ${levelSummary(currentState)}`, "info");
+            if (ctx?.reload)
+                await ctx.reload();
+        },
+    });
+    pi.on("session_start", async (_event, ctx) => {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+        else
+            syncStatus(ctx);
+        // Installer/user-configured default applies only to a fresh session with
+        // no persisted state — real session state always wins.
+        if (getSharedComboState().level === "off" && !(ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || []).length) {
+            const fallback = readComboDefault();
+            if (fallback !== "off") {
+                useState(setSharedComboLevel(fallback), ctx);
+                ctx?.ui?.notify?.(`Combo default applied: ${fallback}`, "info");
+            }
+        }
+    });
+    pi.on("session_branch", async (_event, ctx) => {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+    });
+    pi.on("session_tree", async (_event, ctx) => {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+    });
+    pi.on("agent_start", async (_event, ctx) => {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+    });
+    pi.on("before_agent_start", async (event, ctx) => {
+        if (ctx?.hasUI)
+            reconcile(ctx);
+        if (!isOmpSubagentPrompt(event.systemPrompt))
+            return;
+        const mode = getSharedComboState().ponytail;
+        if (mode === "off" || hasPonytailInstructions(event.systemPrompt))
+            return;
+        const base = Array.isArray(event.systemPrompt) ? event.systemPrompt : [event.systemPrompt];
+        return { systemPrompt: [...base, loadPonytailInstructions(mode)] };
+    });
+    // Slash commands only; natural-language input caused accidental toggles and has no reload context.
+}

package/extensions/lib/utils.js

@@ -0,0 +1,101 @@
+// Shared helpers for the installer and the AI add-ons updater.
+// Node built-ins only — this module must stay dependency-free.
+import { createHash } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import fs from "node:fs/promises";
+import https from "node:https";
+import path from "node:path";
+// Promise.withResolvers is Node 22+; the package supports Node 18+.
+// ponytail: swap for the built-in when engines bumps to >=22.
+function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+    return { promise, resolve, reject };
+}
+export function httpsGet(url, opts = {}) {
+    const { promise, resolve, reject } = withResolvers();
+    const maxRedirects = opts.maxRedirects ?? 5;
+    const req = https.get(url, { headers: { "User-Agent": "tersio", Accept: "application/json,*/*" } }, (res) => {
+        if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            if (maxRedirects <= 0) {
+                res.resume();
+                reject(new Error(`Too many redirects fetching ${url}`));
+                return;
+            }
+            res.resume();
+            const next = new URL(res.headers.location, url).href;
+            resolve(httpsGet(next, { maxRedirects: maxRedirects - 1 }));
+            return;
+        }
+        if (res.statusCode !== 200) {
+            res.resume();
+            reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+            return;
+        }
+        let body = "";
+        // ponytail: streamed accumulation — fine for tens of KB; stream-pipe if assets ever exceed a few MB.
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => { body += chunk; });
+        res.on("end", () => resolve(body));
+    });
+    req.on("error", reject);
+    req.setTimeout(30000, () => req.destroy(new Error(`Timeout fetching ${url}`)));
+    return promise;
+}
+export function httpsDownload(url, dest, opts = {}) {
+    const { promise, resolve, reject } = withResolvers();
+    const maxRedirects = opts.maxRedirects ?? 5;
+    const req = https.get(url, { headers: { "User-Agent": "tersio", Accept: "*/*" } }, (res) => {
+        if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            if (maxRedirects <= 0) {
+                res.resume();
+                reject(new Error(`Too many redirects downloading ${url}`));
+                return;
+            }
+            res.resume();
+            const next = new URL(res.headers.location, url).href;
+            resolve(httpsDownload(next, dest, { maxRedirects: maxRedirects - 1 }));
+            return;
+        }
+        if (res.statusCode !== 200) {
+            res.resume();
+            reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+            return;
+        }
+        const file = createWriteStream(dest);
+        res.pipe(file);
+        file.on("finish", () => file.close(() => resolve()));
+        file.on("error", reject);
+    });
+    req.on("error", reject);
+    req.setTimeout(120000, () => req.destroy(new Error(`Timeout downloading ${url}`)));
+    return promise;
+}
+export function sha256Hex(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+export async function sha256File(filePath) {
+    const buf = await fs.readFile(filePath);
+    return createHash("sha256").update(buf).digest("hex");
+}
+export function parseChecksum(checksumsText, assetName) {
+    const target = path.basename(assetName);
+    for (const line of checksumsText.split(/\r?\n/)) {
+        const m = line.match(/^([0-9a-fA-F]{64})\s+\*?(.+)$/);
+        if (m && path.basename(m[2]) === target)
+            return m[1].toLowerCase();
+    }
+    return null;
+}
+export async function readTextIfExists(p) {
+    try {
+        return await fs.readFile(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeRtkVersion(value) {
+    return String(value || "").replace(/^rtk\s+/i, "").replace(/^v/i, "").trim();
+}

package/extensions/rtk-session/index.js

@@ -0,0 +1,151 @@
+import os from "node:os";
+import path from "node:path";
+import { COMBO_LEVELS, getSharedComboState, isOmpSubagentPrompt, setSharedComboMode } from "../shared/session-state.js";
+import { readRtkDefault } from "../shared/plugin-settings.js";
+const DEFAULT_ENABLED = false;
+function asBoolean(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (value === "on" || value === "true")
+        return true;
+    if (value === "off" || value === "false")
+        return false;
+    return null;
+}
+function resolveEnabled(entries) {
+    if (!Array.isArray(entries))
+        return null;
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+        const entry = entries[i];
+        if (entry?.type !== "custom" || entry?.customType !== "rtk-mode")
+            continue;
+        return asBoolean(entry?.data?.enabled);
+    }
+    return null;
+}
+const IS_WINDOWS = process.platform === "win32";
+const HOME = os.homedir();
+const RTK_BINARY = path.join(HOME, ".bun", "bin", IS_WINDOWS ? "rtk.exe" : "rtk");
+const RTK_PROMPT = `RTK mode active for this session.
+Use Rust Token Killer for shell output that would otherwise be noisy. Prefer explicit RTK commands in bash: \`rtk git status\`, \`rtk git diff\`, \`rtk read <file>\`, \`rtk grep <pattern> <path>\`, \`rtk find <glob> <path>\`, \`rtk test <cmd...>\`, \`rtk tsc\`, \`rtk lint\`, or \`rtk <tool> ...\` for supported dev commands.
+Do not use RTK when exact raw output is required, when a specialized OMP tool is required by system policy, or when the command changes state and RTK would hide important confirmation text. Specialized OMP tools still win: read/glob/grep/edit/lsp stay preferred over shell equivalents.`;
+export default function rtkSessionExtension(pi) {
+    const { z } = pi.zod;
+    let enabled = DEFAULT_ENABLED;
+    let isActive = false;
+    let lastCtx = undefined;
+    function syncStatus(ctx) {
+        if (ctx)
+            lastCtx = ctx;
+        const c = ctx || lastCtx;
+        if (!c?.ui?.setStatus)
+            return;
+        // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
+        if (getSharedComboState().level in COMBO_LEVELS && getSharedComboState().level !== "off") {
+            c.ui.setStatus("rtk", undefined);
+            return;
+        }
+        if (!enabled) {
+            c.ui.setStatus("rtk", undefined);
+            return;
+        }
+        const theme = c.ui.theme;
+        const indicator = isActive && theme?.fg ? theme.fg("accent", "⚡") : "⚡";
+        const label = "rtk: ON";
+        c.ui.setStatus("rtk", theme?.fg ? `${indicator} ${theme.fg("muted", label)}` : `${indicator} ${label}`);
+    }
+    function setEnabled(next, ctx) {
+        enabled = Boolean(next);
+        pi.appendEntry?.("rtk-mode", { enabled });
+        setSharedComboMode("rtk", enabled);
+        syncStatus(ctx);
+        ctx?.ui?.notify?.(`RTK mode ${enabled ? "on" : "off"}.`, "info");
+    }
+    pi.setLabel?.("RTK session toggle");
+    pi.registerCommand?.("rtk", {
+        description: "Toggle RTK compact shell-output guidance for this session",
+        handler: async (args, ctx) => {
+            const arg = String(args || "").trim().toLowerCase();
+            if (!arg || arg === "status") {
+                ctx?.ui?.notify?.(`RTK: ${enabled ? "on" : "off"}`, "info");
+                return;
+            }
+            if (["on", "enable", "enabled", "true"].includes(arg)) {
+                setEnabled(true, ctx);
+                return;
+            }
+            if (["off", "disable", "disabled", "false"].includes(arg)) {
+                setEnabled(false, ctx);
+                return;
+            }
+            ctx?.ui?.notify?.("Usage: /rtk [on|off|status]", "warning");
+        },
+    });
+    pi.registerTool?.({
+        name: "rtk_run",
+        label: "RTK Run",
+        description: "Run the installed `rtk` binary for compact command output when RTK mode is enabled.",
+        parameters: z.object({
+            args: z.array(z.string()).min(1).describe("Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']"),
+        }),
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            if (!enabled) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "RTK mode is off. Run /rtk on for this session, or use bash explicitly." }],
+                    details: { enabled },
+                };
+            }
+            onUpdate?.({ content: [{ type: "text", text: `rtk ${params.args.join(" ")}` }], details: { phase: "start" } });
+            const result = await pi.exec(RTK_BINARY, params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+            const text = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? "\n" : "");
+            return {
+                isError: result.code !== 0,
+                content: [{ type: "text", text: text || `rtk exited ${result.code}` }],
+                details: { code: result.code, killed: result.killed, enabled },
+            };
+        },
+    });
+    pi.on("input", async (event) => {
+        if (event?.source === "extension")
+            return;
+        const t = String(event?.text || "").trim().toLowerCase().replace(/[.!?\s]+$/, "");
+        if (t === "rtk on" || t === "use rtk")
+            setEnabled(true);
+        if (t === "rtk off" || t === "stop rtk")
+            setEnabled(false);
+    });
+    function restoreEnabled(ctx) {
+        const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+        // Persisted session state wins; a fresh session falls back to the
+        // installer/user-configured default (off unless configured).
+        const persisted = resolveEnabled(entries);
+        enabled = typeof persisted === "boolean" ? persisted : readRtkDefault();
+        syncStatus(ctx);
+    }
+    pi.on("session_start", async (_event, ctx) => {
+        restoreEnabled(ctx);
+        ctx?.ui?.notify?.(`RTK loaded: ${enabled ? "on" : "off"}`, "info");
+    });
+    pi.on("session_branch", async (_event, ctx) => {
+        restoreEnabled(ctx);
+    });
+    pi.on("session_tree", async (_event, ctx) => {
+        restoreEnabled(ctx);
+    });
+    pi.on("agent_start", async (_event, ctx) => {
+        isActive = true;
+        syncStatus(ctx);
+    });
+    pi.on("agent_end", async (_event, ctx) => {
+        isActive = false;
+        syncStatus(ctx);
+    });
+    pi.on("before_agent_start", async (event) => {
+        const active = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().rtk === "on" : enabled;
+        if (!active)
+            return;
+        const base = Array.isArray(event.systemPrompt) ? event.systemPrompt : [event.systemPrompt];
+        return { systemPrompt: [...base, RTK_PROMPT] };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Amanai reward detector and three toggleable OMP extensions for terse replies, compact shell output, and minimal code decisions — with a manual updater and dry-run support.",
   "keywords": [
     "omp",
@@ -109,6 +109,7 @@
   "scripts": {
     "clean": "rm -f tersio.js extensions/**/*.js",
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "check": "tsc --noEmit",
     "doctor": "node tersio.js --doctor",
     "dry-run": "node tersio.js --dry-run --scope user --yes",