pluidr 0.4.1 → 0.6.0

package/src/core/squeezeInstaller.js

@@ -0,0 +1,141 @@
+import { execFileSync } from "node:child_process"
+import { chmodSync, mkdirSync, existsSync, writeFileSync, unlinkSync, readFileSync } from "node:fs"
+import { extname, join, resolve, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+import { createHash } from "node:crypto"
+import { getConfigDir } from "./paths.js"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+const BIN_NAME = process.platform === "win32" ? "rtk.exe" : "rtk"
+export const ASSETS = {
+  "darwin-arm64": "rtk-aarch64-apple-darwin.tar.gz",
+  "darwin-x64": "rtk-x86_64-apple-darwin.tar.gz",
+  "linux-x64": "rtk-x86_64-unknown-linux-musl.tar.gz",
+  "linux-arm64": "rtk-aarch64-unknown-linux-gnu.tar.gz",
+  "win32-x64": "rtk-x86_64-pc-windows-msvc.zip",
+}
+const RTK_RELEASE_BASE = "https://github.com/rtk-ai/rtk/releases/latest/download"
+
+export function platformAsset() {
+  const key = `${process.platform}-${process.arch}`
+  return ASSETS[key] ?? null
+}
+
+export function validatePath(path) {
+  if (!/^[a-zA-Z0-9_\-\.\:\/\\]+$/.test(path)) {
+    throw new Error(`Invalid path: "${path}" contains unsafe characters`)
+  }
+}
+
+export function findRtkPath() {
+  try {
+    const [cmd, ...args] =
+      process.platform === "win32" ? ["where", "rtk"] : ["which", "rtk"]
+    return execFileSync(cmd, args, { stdio: "pipe" })
+      .toString()
+      .trim()
+      .split(/\r?\n/)[0]
+  } catch {
+    return null
+  }
+}
+
+function extract(archivePath, destDir) {
+  validatePath(archivePath)
+  validatePath(destDir)
+  const isZip = extname(archivePath) === ".zip"
+
+  if (isZip && process.platform === "win32") {
+    execFileSync("powershell", [
+      "-NoProfile",
+      "-Command",
+      "Expand-Archive",
+      "-LiteralPath", archivePath,
+      "-DestinationPath", destDir,
+      "-Force"
+    ], { stdio: "ignore" })
+  } else {
+    execFileSync("tar", ["-xzf", archivePath, "-C", destDir], { stdio: "ignore" })
+  }
+}
+
+function verifyChecksum(buffer, assetName) {
+  const checksumsPath = resolve(__dirname, "../templates/rtk-checksums.json")
+  let checksums
+  try {
+    checksums = JSON.parse(readFileSync(checksumsPath, "utf-8"))
+  } catch {
+    // No checksums file — skip verification
+    return
+  }
+
+  const expectedHash = checksums[assetName]
+  if (expectedHash === null || expectedHash === undefined) {
+    // Hash not yet populated for this platform — silently skip
+    return
+  }
+
+  const computed = createHash("sha256").update(buffer).digest("hex")
+  if (computed !== expectedHash) {
+    throw new Error(
+      `SHA256 mismatch for ${assetName}\n  expected: ${expectedHash}\n  computed: ${computed}`
+    )
+  }
+}
+
+export async function installSqueeze() {
+  let rtkPath = findRtkPath()
+
+  if (!rtkPath) {
+    // Not on PATH — download it to the managed location
+    const asset = platformAsset()
+    if (!asset) {
+      console.warn("⚠ Squeeze: unsupported platform — install rtk manually")
+      return
+    }
+
+    const binDir = join(getConfigDir(), "bin")
+    mkdirSync(binDir, { recursive: true })
+
+    const url = `${RTK_RELEASE_BASE}/${asset}`
+    const archivePath = join(binDir, asset)
+
+    try {
+      let response
+      for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+          response = await fetch(url)
+          if (!response.ok) throw new Error(`HTTP ${response.status}`)
+          break
+        } catch (err) {
+          if (attempt < 3) {
+            // Retry on any error (network, HTTP, etc.) with exponential backoff
+            const delay = Math.pow(2, attempt - 1) * 1000
+            await new Promise(r => setTimeout(r, delay))
+            continue
+          }
+          throw err
+        }
+      }
+
+      const buffer = Buffer.from(await response.arrayBuffer())
+      verifyChecksum(buffer, asset)
+      writeFileSync(archivePath, buffer)
+
+      extract(archivePath, binDir)
+
+      try { unlinkSync(archivePath) } catch {}
+
+      rtkPath = join(binDir, BIN_NAME)
+
+      if (process.platform !== "win32" && existsSync(rtkPath)) {
+        chmodSync(rtkPath, 0o755)
+      }
+    } catch {
+      try { unlinkSync(archivePath) } catch {}
+      console.warn("⚠ Squeeze: download failed after 3 attempts — install rtk manually")
+      return
+    }
+  }
+}

package/src/core/squeezeInstaller.test.js

@@ -0,0 +1,77 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { platformAsset, validatePath, findRtkPath, ASSETS } from "./squeezeInstaller.js"
+
+describe("platformAsset", () => {
+  it("returns a string or null for current platform", () => {
+    const result = platformAsset()
+    // On a supported platform: string; on unsupported: null
+    assert.ok(result === null || typeof result === "string")
+  })
+
+  it("returns known asset names for mapped platforms", () => {
+    // Verify the ASSETS map has entries for all known platform combos
+    const knownCombos = [
+      { plat: "darwin", arch: "arm64" },
+      { plat: "darwin", arch: "x64" },
+      { plat: "linux", arch: "x64" },
+      { plat: "linux", arch: "arm64" },
+      { plat: "win32", arch: "x64" },
+    ]
+    for (const { plat, arch } of knownCombos) {
+      const key = `${plat}-${arch}`
+      const asset = ASSETS[key]
+      assert.ok(asset, `ASSETS map should have entry for ${key}`)
+      assert.ok(asset.endsWith(".tar.gz") || asset.endsWith(".zip"),
+        `Asset "${asset}" should end with .tar.gz or .zip`)
+    }
+  })
+})
+
+describe("validatePath", () => {
+  it("accepts simple relative paths", () => {
+    assert.doesNotThrow(() => validatePath("foo/bar"))
+  })
+
+  it("accepts absolute POSIX paths", () => {
+    assert.doesNotThrow(() => validatePath("/home/user/.config"))
+  })
+
+  it("accepts absolute Windows paths", () => {
+    assert.doesNotThrow(() => validatePath("C:\\Users\\test"))
+  })
+
+  it("accepts paths with dots and dashes", () => {
+    assert.doesNotThrow(() => validatePath("./dir/file-name.ext"))
+  })
+
+  it("allows .. in paths (shell metacharacter check only, not path traversal)", () => {
+    assert.doesNotThrow(() => validatePath("../evil"))
+  })
+
+  it("rejects paths with semicolons", () => {
+    assert.throws(() => validatePath("foo;rm -rf /"), /unsafe characters/)
+  })
+
+  it("rejects paths with backticks", () => {
+    assert.throws(() => validatePath("foo`id`"), /unsafe characters/)
+  })
+
+  it("rejects paths with dollar signs", () => {
+    assert.throws(() => validatePath("foo$PATH"), /unsafe characters/)
+  })
+
+  it("rejects paths with pipe characters", () => {
+    assert.throws(() => validatePath("foo|bar"), /unsafe characters/)
+  })
+})
+
+describe("findRtkPath", () => {
+  it("returns null when rtk is not available on PATH", () => {
+    // This test is safe because if rtk IS on PATH, we still get a
+    // string back — but the test doesn't crash either way.
+    const result = findRtkPath()
+    // Either null (not on PATH) or a non-empty string (found)
+    assert.ok(result === null || typeof result === "string")
+  })
+})

package/src/plugins/README.md

@@ -2,13 +2,13 @@
 
 This folder holds plugin source files that `pluidr init` copies into the
 user's OpenCode plugin directory (`~/.config/opencode/plugins/`), giving
-subagents cross-session context tools out of the box.
+subagents cross-session context tools and command output filtering out of
+the box.
 
-## What is `parent-session.js`?
+## `pluidr-flow.js` — cross-session context
 
-It is the implementation of the `ParentSessionPlugin`, registered by
-OpenCode at startup. It exposes three tools that subagents use to read
-the conversation history of related sessions (parent, sibling, or batch):
+Implementation of the `SessionFlowPlugin`. Exposes three tools for reading
+conversation history across related sessions (parent, sibling, or batch):
 
 - `parent_session_messages` — read the parent session's full transcript
 - `session_messages(sessionId)` — read any session by ID
@@ -18,7 +18,21 @@ The output is a structured text dump with numbered messages, agent
 attribution, and one-line tool-invocation summaries, separated by
 `\n\n---\n\n`.
 
-## Why `parent-session` was extracted
+## `pluidr-squeeze.js` — command output filtering
+
+Implementation of the `PluidrSqueezePlugin`. Hooks into `tool.execute.before`
+to rewrite bash commands through the `rtk` binary. The binary filters,
+groups, truncates, and deduplicates command output — saving 60-90% of
+tokens across all agents.
+
+The plugin is a thin delegator: all rewrite logic lives in the `rtk` binary.
+It checks `PATH` first, then falls back to Pluidr's managed location at
+`~/.config/opencode/bin/rtk`. If the binary is not found, the plugin
+gracefully disables itself with a warning.
+
+`pluidr init` downloads the `rtk` binary automatically during setup.
+
+## Why `pluidr-flow` was extracted
 
 Subagents (Coder, Tester, Reviewer, Inspector, Fixer, etc.) run in fresh
 child sessions with no access to the parent orchestrator's conversation
@@ -31,7 +45,7 @@ and pick up where the parent left off.
 ## Why the identity plugin was dropped
 
 The original `AgentSelfIdentityPlugin` injected agent identity via
-`experimental.chat.*` hooks. Pluidr's 14 agent names are known at install
+`experimental.chat.*` hooks. Pluidr's 12 agent names are known at install
 time, so we prepend a static identity header (`You are the "<name>" agent.`)
 to every generated prompt file. This is KISS: no hook evaluation per
 request, no dependency on undocumented experimental APIs, single source
@@ -43,12 +57,12 @@ The original `AgentAttributionToolPlugin` was designed for a Retrospective
 agent that captures post-session observations. Pluidr has no Retrospective
 agent in its pipeline, so the tool would have no caller — YAGNI.
 
-## How it is loaded
+## How they are loaded
 
-`pluidr init` copies `parent-session.js` into
-`~/.config/opencode/plugins/` and writes a `package.json` next to it
-declaring `@opencode-ai/plugin: ^1.17.9` as a dependency. On OpenCode's
-first launch, the bundled Bun runtime detects the `package.json` and runs
-`bun install` automatically — no user action required. Once installed,
-the plugin's three tools are available to every agent that has the
-appropriate permissions.
+`pluidr init` copies both plugins into `~/.config/opencode/plugins/` and
+writes a `package.json` declaring `@opencode-ai/plugin: ^1.17.9` as a
+dependency. For `pluidr-squeeze`, it also downloads the `rtk` engine binary
+to `~/.config/opencode/bin/`. On OpenCode's first launch, the bundled Bun
+runtime detects the `package.json` and runs `bun install` automatically —
+no user action required. Once installed, both plugins are available to
+every agent that has the appropriate permissions.

package/src/plugins/{parent-session.js → pluidr-flow.js}

@@ -1,8 +1,3 @@
-// Parent-session plugin: provides tools for cross-session context access in
-// subagent workflows. Translated from the original TypeScript implementation
-// in addition/opencode-session-context/src/parent-session.ts to plain ESM JS
-// (no build step required). Behavior, formatting, and tool names are unchanged.
-
 import { tool } from "@opencode-ai/plugin"
 
 function formatInput(input) {
@@ -56,7 +51,7 @@ function formatMessage(msg, index) {
   return `${num}. ${msg.info.role}\n${formatParts(msg.parts)}`
 }
 
-export const ParentSessionPlugin = async ({ client }) => {
+export const SessionFlowPlugin = async ({ client }) => {
   async function formatSessionMessages(sessionID, emptyMessage) {
     const response = await client.session.messages({
       path: { id: sessionID },

package/src/plugins/pluidr-squeeze.js

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+const BIN_NAME = process.platform === "win32" ? "rtk.exe" : "rtk"
+const SQUEEZE_BIN = join(homedir(), ".config", "opencode", "bin", BIN_NAME)
+
+function normalise(p) {
+  return p.replace(/\\/g, "/")
+}
+
+async function findBinary($) {
+  try {
+    if (process.platform === "win32") {
+      await $`where rtk`.quiet()
+    } else {
+      await $`which rtk`.quiet()
+    }
+    return "rtk"
+  } catch {
+    if (existsSync(SQUEEZE_BIN)) {
+      return normalise(SQUEEZE_BIN)
+    }
+    return null
+  }
+}
+
+export const PluidrSqueezePlugin = async ({ $ }) => {
+  const binPath = await findBinary($)
+  if (!binPath) {
+    console.warn("[squeeze] rtk binary not found — plugin disabled")
+    return {}
+  }
+
+  return {
+    "tool.execute.before": async (input, output) => {
+      const tool = String(input?.tool ?? "").toLowerCase()
+      if (tool !== "bash" && tool !== "shell") return
+      const args = output?.args
+      if (!args || typeof args !== "object") return
+
+      const command = args.command
+      if (typeof command !== "string" || !command) return
+
+      try {
+        const result = await $`${binPath} rewrite ${command}`.quiet().nothrow()
+        const rewritten = String(result.stdout).trim()
+        if (rewritten && rewritten !== command) {
+          args.command = rewritten
+        }
+      } catch {
+        // rewrite failed — pass through unchanged
+      }
+    },
+  }
+}

package/src/templates/agent-prompts/auditor.txt

@@ -0,0 +1,20 @@
+# Role: Auditor Subagent
+
+You are the **Auditor** subagent for the **Prober** agent. You act as a strict validation gate checking if security patches have resolved the vulnerabilities and ensuring no over-engineering was introduced.
+
+## Auditor MUST NOT
+- Propose remedies, suggest code adjustments, or edit code.
+
+## Auditor MAY ONLY
+- Inspect modified codebase files and run test commands to verify vulnerability elimination.
+- Perform a security regression review: ensure the applied patches did not introduce new vulnerability pathways (e.g., input bypasses or insecure error handling).
+- Perform an over-engineering review (Ponytail audit lens).
+
+## Ponytail Audit Lens (Bloat Analysis)
+Analyze changes for cognitive overload, accidental complexity, or redundant logic. Compile a list of unrequested abstractions, boilerplate, or excessive lines.
+
+## Output Format
+Your output must consist ONLY of:
+- **Verdict**: PASS or FAIL
+- **Gap List**: Specific files/lines where vulnerabilities are still active or regression was detected (FAIL cases only).
+- **BLOAT List**: List of over-engineered constructs found in the patches.

package/src/templates/agent-prompts/coder.txt

@@ -1,8 +1,6 @@
 # Role: Coder Subagent
 
-You implement tasks assigned by Builder, following the PRD exactly. You
-manage your own task tracking internally via `todowrite` — this is not a
-persisted document, it's your working checklist for the current session.
+You implement tasks assigned by Composer. If a PRD is provided, follow it exactly. If no PRD is provided (e.g., during a direct-build phase for simple tasks), follow the user's original specification and the Explore findings provided in the task payload verbatim. You manage your own task tracking internally via `todowrite` — this is not a persisted document, it's your working checklist for the current session.
 
 Refer to `hierarchy.txt` (loaded globally) for conflict resolution.
 
@@ -39,7 +37,7 @@ Refer to `hierarchy.txt` (loaded globally) for conflict resolution.
 You have no `task` permission — you cannot invoke any other agent or
 subagent. If implementation reveals a need for research (e.g., unclear
 library behavior) or a requirement question, stop and report back to
-Builder rather than guessing or trying to research it yourself outside
+Composer rather than guessing or trying to research it yourself outside
 your given tools.
 
 ## Task tracking
@@ -52,11 +50,39 @@ your given tools.
 ## What you do NOT do
 
 - You do not change the requirement — if the PRD task is ambiguous or
-  infeasible as written, stop and report back to Builder rather than
+  infeasible as written, stop and report back to Composer rather than
   reinterpreting it.
-- You do not produce documentation — that's Writer's job.
+- You do not produce documentation — that's Compose-Reporter's job.
 
 ## Output
 
 - Code changes, with a brief note on any deviation from the assigned task (if any).
-- Flag any duplicated logic found during implementation.
+- Flag any duplicated logic found during implementation.
+
+## Efficiency Constraints
+
+**Decision Ladder**
+Before writing any code, stop at the first rung that holds:
+1. Does this need to be built at all? (YAGNI)
+2. Does it already exist in this codebase? Reuse the helper, util, or pattern that's already here, don't re-write it.
+3. Does the standard library already do this? Use it.
+4. Does a native platform feature cover it? Use it.
+5. Does an already-installed dependency solve it? Use it.
+6. Can this be one line? Make it one line.
+7. Only then: write the minimum code that works.
+
+The ladder runs after you understand the problem: read the task and the code it touches, trace the real flow end to end, then climb.
+
+**Never-Simplify Rules (Not Lazy About)**
+- Understanding the problem: Trace the real flow before coding.
+- Input validation at trust boundaries.
+- Error handling that prevents data loss.
+- Security and accessibility.
+- Anything explicitly requested.
+- No abstractions that weren't explicitly requested.
+- No new dependency if it can be avoided.
+- No boilerplate nobody asked for.
+- Deletion over addition. Boring over clever. Fewest files possible.
+
+**Simplification Comment Convention**
+- Mark intentional simplifications with a `simplification:` comment. If the shortcut has a known ceiling (global lock, O(n²) scan, naive heuristic), the comment must name the ceiling and the upgrade path.

package/src/templates/agent-prompts/{writer.txt → compose-reporter.txt}

@@ -1,29 +1,29 @@
-# Role: Writer Subagent
+# Role: Compose-Reporter Subagent
 
-You are the **Writer** subagent, the text-file executor for the **Builder**
+You are the **Compose-Reporter** subagent, the text-file executor for the **Composer**
 agent. You write and edit `.md` and `.txt` files across the project — like
 Coder but for documents only. You do not run bash commands.
 
 ## Mode: Document Creation / Editing
 
 You create and modify documentation files (.md, .txt) as instructed by
-Builder. You may also be invoked in Summary mode to produce completion
+Composer. You may also be invoked in Summary mode to produce completion
 reports from structured input.
 
 ## Delegation rules
 
 You have no `task` permission — you cannot invoke any other agent or
-subagent. If Builder's instructions are insufficient to produce the
+subagent. If Composer's instructions are insufficient to produce the
 required document, mark missing sections as `TBD` — do not infer, research,
 or invent content.
 
 ## Principles
 
-- **Audience-First** — Structure the document for its reader. If Builder specifies an audience (technical lead, maintainer, end-user), tailor detail level and vocabulary accordingly. If no audience is specified, default to technical summary.
+- **Audience-First** — Structure the document for its reader. If Composer specifies an audience (technical lead, maintainer, end-user), tailor detail level and vocabulary accordingly. If no audience is specified, default to technical summary.
 - **DRY for Docs** — Each finding or verdict appears exactly once with cross-references. Do not repeat the same information across sections — it creates maintenance burden and risks inconsistency.
 - **KISS** — Prefer simple, flat structure over nested hierarchies. A reader should grasp the outcome from the first paragraph.
 
-## Writer MUST NOT
+## Compose-Reporter MUST NOT
 
 - Make inferences about what the user "probably means."
 - Make decisions (e.g., which approach is better).
@@ -31,7 +31,7 @@ or invent content.
 - Fill missing information with assumptions — mark as `TBD` instead.
 - Run bash commands — you have no `bash` permission.
 
-## Writer MAY ONLY
+## Compose-Reporter MAY ONLY
 
 - Write and edit `.md` and `.txt` files as instructed.
 - Reformat / restructure given input into the target document type.