@krtclcdy/tersio 2.25.5 → 2.25.7

package/dist/extensions/rtk/filter.js

@@ -34,7 +34,6 @@ export function rtkActive(entries) {
 export function filterableText(parts) {
     if (!Array.isArray(parts) || parts.length === 0)
         return null;
-    // An image or a mixed result is not text to filter.
     if (parts.some((part) => part?.type !== 'text'))
         return null;
     return parts.map((part) => part?.text ?? '').join('\n');

package/dist/extensions/rtk/session.js

@@ -22,8 +22,11 @@ function setRtkProcessEnabled(enabled) {
     else
         process.env.RTK_DISABLED = '1';
 }
-// rtk's awareness contract: state the output contract, never tell the model to type `rtk`.
-const RTK_PROMPT = `RTK guidance active. Bash output, and large grep and glob results, are condensed to save tokens: every signal kept, costly noise dropped. Treat a condensed result as complete. Re-run something unfiltered only when its result is empty, garbled, or contradicts its exit code.`;
+// rtk's contract: name the rewritten surface first and the binary second — a hand-typed `rtk` in front of a
+// rewritten command fights the rewrite, and the direct calls cover only what the rewrite cannot express.
+const RTK_PROMPT = `RTK guidance active. What you run is condensed automatically, in the host's own rewritten form: searches (grep, rg, ast-grep), listings (ls, find, tree), reads (cat), package and test runs (bun, npm, pnpm, npx, cargo, go, pytest, vitest, jest, ctest, tsc), version control and forges (git, gh, glab), containers and clusters (docker, kubectl), cloud and platform CLIs (aws, oc, dotnet), PHP tooling (phpunit, pest, phpstan, pint, ecs), lint and format (eslint, ruff, mypy, prettier, sqlfluff, playwright, prisma, next), and data tools (jq, curl, wget, psql, wc, make, tail, docker logs). The runner's own subcommand, such as \`rtk bun run test\`, keeps the failing test name, the assertion, and the file and line. Every signal kept, costly noise dropped. Treat a condensed result as complete. Re-run something unfiltered only when its result is empty, garbled, or contradicts its exit code.
+
+Call rtk directly for what the rewrite cannot express: \`rtk read <file> --level aggressive\` for an overview, \`--max-lines N\` for a preview, \`rtk smart <file>\` for a two-line summary, \`rtk summary <cmd>\` for a heuristic one, \`rtk err <cmd>\` for errors only, \`rtk log <file>\` to dedupe logs, \`rtk json <file>\` with \`--keys-only\` for shape, plus \`rtk deps\`, \`rtk diff\`, \`rtk env\`, \`rtk ast-grep\`, and \`rtk test <cmd>\` for a runner without its own form. A command with no condensed form passes through unchanged, so wrap it: \`rtk err node build.js\`, and \`rtk find -name '*.ts'\` in place of fd. Never type \`rtk\` in front of a command listed above.`;
 export default function rtkSessionExtension(pi) {
     let enabled = DEFAULT_ENABLED;
     function fail(text) {
@@ -37,7 +40,7 @@ export default function rtkSessionExtension(pi) {
         announceStatus(ctx);
     }
     setExtensionLabel(pi, 'RTK session toggle');
-    // Live mirror: a /tersio or /combo switch publishes shared state — adopt it at once so the next turn and the rtk_run gate see it, no reload.
+    // Live mirror: a /tersio or /combo switch publishes shared state — adopt it once so the next turn and rtk_run see it.
     function syncFromShared(state) {
         enabled = state.rtk === 'on';
         setRtkProcessEnabled(enabled);
@@ -65,30 +68,35 @@ export default function rtkSessionExtension(pi) {
     pi.registerTool?.({
         name: 'rtk_run',
         label: 'RTK Run',
-        description: 'Run the installed `rtk` binary for compact command output when RTK mode is enabled.',
+        description: 'Run a shell command through the installed `rtk` binary when RTK mode is on, and run it plainly when RTK mode is off.',
         parameters: stringArrayToolParams(pi, 'args', {
             minItems: 1,
             description: "Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']",
         }),
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
             // A subagent's own flag sits at its start-up default, so honour shared state too.
-            if (!(enabled || getSharedComboState().rtk === 'on'))
-                return fail('RTK mode is off. Run /rtk on for this session, or use bash explicitly.');
+            const rtkOn = enabled || getSharedComboState().rtk === 'on';
             if (typeof pi.exec !== 'function')
                 return fail('This host cannot run rtk.');
-            onUpdate?.({ content: [{ type: 'text', text: `rtk ${params.args.join(' ')}` }], details: { phase: 'start' } });
+            // RTK off: run the command as given rather than answering "mode is off". The tool is the only one left under --no-tools, and a refusal there made the model spend turns re-calling it. rtk is the condenser, never the command.
+            const cwd = ctx?.cwd || pi.cwd;
+            const bin = rtkOn ? resolveRtkBinary() : null;
+            if (rtkOn && bin === null)
+                return fail('RTK mode is on but the rtk binary is not installed. Run: tersio update');
+            const argv = params.args;
+            onUpdate?.({ content: [{ type: 'text', text: `${bin === null ? '' : 'rtk '}${argv.join(' ')}` }], details: { phase: 'start' } });
             try {
                 // A GUI-launched host may lack ~/.bun/bin on PATH, so prefer the resolved path.
-                const result = await pi.exec(resolveRtkBinary() ?? 'rtk', params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+                const result = await pi.exec(bin ?? argv[0], argv, { signal, cwd });
                 const text = [result.stdout, result.stderr].filter(Boolean).join('\n');
                 return {
                     isError: result.code !== 0,
-                    content: [{ type: 'text', text: text || `rtk exited ${result.code}` }],
-                    details: { code: result.code, killed: result.killed, enabled },
+                    content: [{ type: 'text', text: text || `exited ${result.code}` }],
+                    details: { code: result.code, killed: result.killed, enabled, condensed: bin !== null },
                 };
             }
             catch (e) {
-                return fail(`rtk could not run: ${e instanceof Error ? e.message : String(e)}`);
+                return fail(`${bin === null ? argv[0] : 'rtk'} could not run: ${e instanceof Error ? e.message : String(e)}`);
             }
         },
     });
@@ -97,7 +105,7 @@ export default function rtkSessionExtension(pi) {
         // A subagent's branch has no Tersio entries; reconciling it would wipe shared state.
         if (hasModeState(entries))
             reconcileSharedComboEntries(entries);
-        // Persisted session state wins; a fresh session falls back to the installer/user-configured default (off unless configured).
+        // Persisted session state wins; a fresh session falls back to the installer/user default (off unless configured).
         const persisted = resolveEnabled(entries);
         enabled = typeof persisted === 'boolean' ? persisted : enabled || readRtkDefault();
         setRtkProcessEnabled(enabled);

package/dist/extensions/server.js

@@ -1,6 +1,10 @@
 // OpenCode plugin entry: maps its plugin API onto the shared ExtensionApi the mode extensions consume.
 import { execFile } from 'node:child_process';
+import { readFileSync, readdirSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import cavemanSessionExtension from './caveman/index.js';
+import pstackSessionExtension from './pstack/index.js';
 import rtkSessionExtension from './rtk/session.js';
 import rtkFilterExtension, { FILTER_BY_TOOL, MIN_FILTER_BYTES, filterThroughRtk, filterableText, rtkActive } from './rtk/filter.js';
 import comboToggleExtension from './combo/index.js';
@@ -20,8 +24,7 @@ const plugin = {
             const own = (await ctx.storage.get(`entries:${sid}`)) ?? [];
             if (own.length)
                 return own;
-            // Pre-scoped installs kept one global list; adopt it once, then diverge.
-            // Clear it after adoption so it can never shadow saved defaults later.
+            // Pre-scoped installs kept one global list; adopt it once and clear it so it cannot shadow saved defaults later.
             const legacy = (await ctx.storage.get('entries')) ?? [];
             if (legacy.length)
                 void ctx.storage.set('entries', []).catch(() => { });
@@ -112,7 +115,7 @@ const plugin = {
                 lifecycle.set(event, list);
             },
         };
-        for (const extension of [cavemanSessionExtension, rtkSessionExtension, rtkFilterExtension, comboToggleExtension, tersioCommandsExtension])
+        for (const extension of [cavemanSessionExtension, pstackSessionExtension, rtkSessionExtension, rtkFilterExtension, comboToggleExtension, tersioCommandsExtension])
             extension(host);
         // The first hook of an unseen session runs its session_start handlers.
         const sidOf = (value) => typeof value === 'string' && value ? value : undefined;
@@ -127,8 +130,7 @@ const plugin = {
                             await ensureSession(sid);
                         const text = typeof input.prompt?.text === 'string' ? input.prompt.text : '';
                         const args = text.includes(' ') ? text.slice(text.indexOf(' ') + 1).trim() : '';
-                        // The shared handlers report through ui.notify, which has no OpenCode
-                        // surface. Collect it and send it back so a command never answers blank.
+                        // Shared handlers notify via ui.notify, which OpenCode lacks; echo it back so a command does not answer blank.
                         const notes = [];
                         const cmdCtx = {
                             ...stubCtx(sid),
@@ -163,6 +165,16 @@ const plugin = {
                 });
             }
         });
+        // The tree ships the ruleset beside the extensions, and OpenCode reads no node_modules from a plugin dir.
+        try {
+            await ctx.skill.transform((editor) => {
+                for (const skill of bundledSkills())
+                    editor.add(skill);
+            });
+        }
+        catch {
+            // Hosts without the skill transform keep the ruleset in the prompt alone.
+        }
         await ctx.session.hook('context', async (event) => {
             const sid = sidOf(event.sessionID);
             if (sid)
@@ -198,6 +210,12 @@ const plugin = {
             const input = event.input;
             if (typeof input?.command !== 'string' || !input.command)
                 return;
+            // /rtk off must stop the rewrite too, or the mode switch only silences the prompt block.
+            const sid = typeof event.sessionID === 'string' ? event.sessionID : activeSid;
+            if (sid !== undefined)
+                await ensureSession(sid);
+            if (!rtkActive(sid === undefined ? undefined : sessionEntriesOf(sid)))
+                return;
             const rewritten = await rewriteCommand(input.command);
             if (rewritten)
                 input.command = rewritten;
@@ -246,6 +264,64 @@ function execRtk(cmd, args, opts) {
         });
     });
 }
+/** `rtk rewrite` exit codes: 0 rewrite found, 1 no equivalent, 3 advisory; the code is the contract. */
+const RTK_REWRITE_FOUND = 0;
+const RTK_REWRITE_ADVISORY = 3;
+/** The bundled ruleset's skill dirs, beside the plugin entry: OpenCode reads no node_modules from a plugin. */
+const PONYTAIL_BUNDLE_SKILLS = join(dirname(fileURLToPath(import.meta.url)), 'ponytail-bundle', 'skills');
+/** Frontmatter a SKILL.md carries: flat keys only, the shape every bundled skill uses. */
+function parseSkillFile(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---[^\S\n]*\r?\n?([\s\S]*)$/);
+    if (!match)
+        return null;
+    const field = (key) => {
+        const lines = match[1].split(/\r?\n/);
+        const at = lines.findIndex((line) => line.startsWith(`${key}:`));
+        if (at === -1)
+            return undefined;
+        const value = lines[at].slice(key.length + 1).trim();
+        if (value[0] !== '>' && value[0] !== '|')
+            return value;
+        // Folded (`>`) joins the indented lines; the next unindented key ends the block.
+        const block = [];
+        for (const line of lines.slice(at + 1)) {
+            if (line.trim() !== '' && !/^\s/.test(line))
+                break;
+            block.push(line.trim());
+        }
+        while (block.length > 0 && block[block.length - 1] === '')
+            block.pop();
+        return block.join(value[0] === '|' ? '\n' : ' ');
+    };
+    const id = field('name') ?? basename(dirname(file));
+    return { id, name: id, description: field('description') ?? '', path: file, content: match[2] };
+}
+/** Every bundled skill, or an empty list when the installer has not bundled them. */
+function bundledSkills() {
+    let entries;
+    try {
+        entries = readdirSync(PONYTAIL_BUNDLE_SKILLS, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!entry.isDirectory())
+            continue;
+        const skill = parseSkillFile(join(PONYTAIL_BUNDLE_SKILLS, entry.name, 'SKILL.md'));
+        if (skill)
+            out.push(skill);
+    }
+    return out;
+}
 function rewriteCommand(command) {
     const bin = resolveRtkBinary();
     if (!bin)
@@ -256,8 +332,16 @@ function rewriteCommand(command) {
             const err = error;
             if (err && (err.killed || err.signal))
                 return resolve(null);
+            const code = typeof err?.code === 'number' ? err.code : RTK_REWRITE_FOUND;
+            // Exit 1 is the only "no equivalent" answer, so anything else with output rewrites.
+            if (code === 1)
+                return resolve(null);
             const out = String(stdout).trim();
-            resolve(out && out !== command ? out : null);
+            if (!out || out === command)
+                return resolve(null);
+            if (code !== RTK_REWRITE_FOUND && code !== RTK_REWRITE_ADVISORY)
+                return resolve(null);
+            resolve(out);
         });
     });
 }