pluidr 0.4.1 → 0.5.0

package/src/core/agentPromptWriter.test.js

@@ -0,0 +1,56 @@
+import { describe, it, after } from "node:test"
+import assert from "node:assert"
+import { existsSync, mkdtempSync, writeFileSync, readFileSync, rmSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { writeAgentPrompts } from "./agentPromptWriter.js"
+
+describe("agentPromptWriter", () => {
+  const destDir = mkdtempSync(join(tmpdir(), "pluidr-apw-dest-"))
+
+  after(() => {
+    // Clean up any files written during tests
+    if (existsSync(destDir)) rmSync(destDir, { recursive: true })
+  })
+
+  it("prepends identity header to agent prompts", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "apw-source-"))
+    const agentPromptsDir = join(tmpDir, "agent-prompts")
+    mkdirSync(agentPromptsDir, { recursive: true })
+
+    writeFileSync(join(agentPromptsDir, "coder.txt"), "test instructions", "utf-8")
+    writeFileSync(join(agentPromptsDir, "writer.txt"), "write docs", "utf-8")
+
+    writeAgentPrompts(tmpDir, destDir)
+
+    const coderContent = readFileSync(join(destDir, "coder.txt"), "utf-8")
+    const writerContent = readFileSync(join(destDir, "writer.txt"), "utf-8")
+
+    assert.ok(coderContent.startsWith('You are the "coder" agent.\n\n'),
+      "coder should have identity header")
+    assert.ok(writerContent.startsWith('You are the "writer" agent.\n\n'),
+      "writer should have identity header")
+    assert.ok(coderContent.includes("test instructions"),
+      "original content preserved in coder")
+    assert.ok(writerContent.includes("write docs"),
+      "original content preserved in writer")
+
+    rmSync(tmpDir, { recursive: true })
+  })
+
+  it("copies hierarchy.txt verbatim without identity header", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "apw-source2-"))
+    const agentPromptsDir = join(tmpDir, "agent-prompts")
+    mkdirSync(agentPromptsDir, { recursive: true })
+
+    writeFileSync(join(agentPromptsDir, "hierarchy.txt"), "global reference rules", "utf-8")
+
+    writeAgentPrompts(tmpDir, destDir)
+
+    const hierarchyContent = readFileSync(join(destDir, "hierarchy.txt"), "utf-8")
+    assert.strictEqual(hierarchyContent, "global reference rules",
+      "hierarchy.txt should be copied verbatim without header")
+
+    rmSync(tmpDir, { recursive: true })
+  })
+})

package/src/core/backup.js

@@ -1,8 +1,38 @@
-import { existsSync, copyFileSync } from "node:fs"
-import { getConfigPath, getBackupPath } from "./paths.js"
+import { existsSync, copyFileSync, readdirSync, unlinkSync } from "node:fs"
+import { join, dirname } from "node:path"
+import { getConfigPath } from "./paths.js"
 
-export function backupExistingConfig() {
-  if (existsSync(getConfigPath())) {
-    copyFileSync(getConfigPath(), getBackupPath())
+const MAX_BACKUPS = 5
+
+function timestamp() {
+  const d = new Date()
+  const pad = (n) => String(n).padStart(2, "0")
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`
+}
+
+function rotateBackups(configPath) {
+  const dir = dirname(configPath)
+  const baseName = "opencode.jsonc.bak"
+  let backups = []
+
+  try {
+    backups = readdirSync(dir)
+      .filter((f) => f.startsWith(baseName + "."))
+      .map((f) => join(dir, f))
+      .sort()
+  } catch { /* dir doesn't exist yet */ }
+
+  while (backups.length >= MAX_BACKUPS) {
+    const oldest = backups.shift()
+    try { unlinkSync(oldest) } catch {}
   }
 }
+
+export function backupExistingConfig(configPath) {
+  const resolvedPath = configPath || getConfigPath()
+  if (!existsSync(resolvedPath)) return
+
+  rotateBackups(resolvedPath)
+  const backupPath = `${resolvedPath}.bak.${timestamp()}`
+  copyFileSync(resolvedPath, backupPath)
+}

package/src/core/backup.test.js

@@ -0,0 +1,51 @@
+import { describe, it, before, after } from "node:test"
+import assert from "node:assert"
+import { existsSync, writeFileSync, readFileSync, rmSync, readdirSync, mkdirSync, mkdtempSync } from "node:fs"
+import { join, dirname } from "node:path"
+import { tmpdir } from "node:os"
+import { backupExistingConfig } from "./backup.js"
+
+describe("backup", () => {
+  const tempDir = mkdtempSync(join(tmpdir(), "pluidr-backup-"))
+  const configPath = join(tempDir, "opencode.jsonc")
+  const TEST_CONTENT = JSON.stringify({ test: true })
+
+  function findBackups() {
+    try {
+      return readdirSync(tempDir).filter((f) => f.startsWith("opencode.jsonc.bak."))
+    } catch { return [] }
+  }
+
+  before(() => {
+    mkdirSync(tempDir, { recursive: true })
+  })
+
+  after(() => {
+    if (existsSync(tempDir)) rmSync(tempDir, { recursive: true })
+  })
+
+  it("skips if no config exists (no throw)", () => {
+    // Ensure no config file exists in temp dir
+    if (existsSync(configPath)) rmSync(configPath)
+    for (const bak of findBackups()) {
+      rmSync(join(tempDir, bak))
+    }
+    backupExistingConfig(configPath)
+    assert.ok(true)
+  })
+
+  it("copies existing config to backup with timestamped name", () => {
+    // Write test config
+    writeFileSync(configPath, TEST_CONTENT, "utf-8")
+
+    backupExistingConfig(configPath)
+
+    const backups = findBackups()
+    assert.ok(backups.length > 0, "timestamped backup file should exist")
+    const newest = backups.sort().reverse()[0]
+    const newestPath = join(tempDir, newest)
+    assert.ok(newestPath.includes("opencode.jsonc.bak."), "backup should be timestamped")
+    const backupContent = JSON.parse(readFileSync(newestPath, "utf-8"))
+    assert.deepStrictEqual(backupContent, { test: true })
+  })
+})

package/src/core/configBuilder.js

@@ -8,6 +8,19 @@ export function buildConfig(tierChoices, templatesDir) {
   const config = JSON.parse(readFileSync(configPath, "utf-8"))
   const modelDefaults = JSON.parse(readFileSync(defaultsPath, "utf-8"))
 
+  // Validate: every agent in model-defaults must have a key in config.agent
+  const defaultedAgents = new Set(
+    Object.values(modelDefaults).flatMap((tier) => tier.agents),
+  )
+  const missingAgents = [...defaultedAgents].filter(
+    (name) => !(name in config.agent),
+  )
+  if (missingAgents.length > 0) {
+    throw new Error(
+      `Template validation failed: agent(s) not found in opencode.config.json: ${missingAgents.join(", ")}`,
+    )
+  }
+
   for (const [tierKey, tier] of Object.entries(modelDefaults)) {
     const model = tierChoices[tierKey]
     for (const agentName of tier.agents) {

package/src/core/configBuilder.test.js

@@ -0,0 +1,47 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { buildConfig } from "./configBuilder.js"
+
+describe("configBuilder", () => {
+  it("injects models into agent config per tier", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "configbuilder-test-"))
+
+    const configJson = {
+      agent: {
+        composer: {},
+        coder: {},
+      },
+    }
+    const defaultsJson = {
+      reasoningHeavy: {
+        provider: "test",
+        model: "big-model",
+        agents: ["composer"],
+      },
+      fast: {
+        provider: "test",
+        model: "small-model",
+        agents: ["coder"],
+      },
+    }
+
+    writeFileSync(join(tmpDir, "opencode.config.json"), JSON.stringify(configJson), "utf-8")
+    writeFileSync(join(tmpDir, "model-defaults.json"), JSON.stringify(defaultsJson), "utf-8")
+
+    const result = buildConfig(
+      {
+        reasoningHeavy: "test/big-model",
+        fast: "test/small-model",
+      },
+      tmpDir,
+    )
+
+    assert.strictEqual(result.agent.composer.model, "test/big-model")
+    assert.strictEqual(result.agent.coder.model, "test/small-model")
+
+    rmSync(tmpDir, { recursive: true })
+  })
+})

package/src/core/configWriter.js

@@ -1,7 +1,10 @@
 import { mkdirSync, writeFileSync } from "node:fs"
-import { getConfigDir, getConfigPath } from "./paths.js"
+import { join } from "node:path"
+import { getConfigDir } from "./paths.js"
 
-export function writeConfig(configObject) {
-  mkdirSync(getConfigDir(), { recursive: true })
-  writeFileSync(getConfigPath(), JSON.stringify(configObject, null, 2), "utf-8")
+export function writeConfig(configObject, targetDir) {
+  const baseDir = targetDir || getConfigDir()
+  const configPath = join(baseDir, "opencode.jsonc")
+  mkdirSync(baseDir, { recursive: true })
+  writeFileSync(configPath, JSON.stringify(configObject, null, 2), "utf-8")
 }

package/src/core/configWriter.test.js

@@ -0,0 +1,26 @@
+import { describe, it, after } from "node:test"
+import assert from "node:assert"
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { writeConfig } from "./configWriter.js"
+
+describe("configWriter", () => {
+  const tempDir = mkdtempSync(join(tmpdir(), "pluidr-configwriter-"))
+
+  after(() => {
+    if (existsSync(tempDir)) rmSync(tempDir, { recursive: true })
+  })
+
+  it("writes config as formatted JSON to the correct path", () => {
+    const configObj = { agent: { composer: { model: "test/model" } } }
+    const expected = JSON.stringify(configObj, null, 2)
+
+    writeConfig(configObj, tempDir)
+
+    const configPath = join(tempDir, "opencode.jsonc")
+    assert.ok(existsSync(configPath), "config file should exist")
+    const written = readFileSync(configPath, "utf-8")
+    assert.strictEqual(written, expected)
+  })
+})

package/src/core/identityHeader.test.js

@@ -0,0 +1,15 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import IDENTITY_HEADER from "./identityHeader.js"
+
+describe("identityHeader", () => {
+  it('returns "You are the <name> agent.\\n\\n" format', () => {
+    const result = IDENTITY_HEADER("coder")
+    assert.strictEqual(result, 'You are the "coder" agent.\n\n')
+  })
+
+  it('handles multi-word agent names', () => {
+    const result = IDENTITY_HEADER("plan-writer")
+    assert.strictEqual(result, 'You are the "plan-writer" agent.\n\n')
+  })
+})

package/src/core/paths.js

@@ -3,18 +3,7 @@ import { join } from "node:path"
 
 const BASE = join(homedir(), ".config", "opencode")
 
-export function getConfigDir() {
-  return BASE
-}
-
-export function getConfigPath() {
-  return join(BASE, "opencode.jsonc")
-}
-
-export function getBackupPath() {
-  return join(BASE, "opencode.jsonc.bak")
-}
-
-export function getPromptsDir() {
-  return join(BASE, "prompts")
-}
+export const getConfigDir = () => BASE
+export const getConfigPath = () => join(BASE, "opencode.jsonc")
+export const getBackupPath = () => join(BASE, "opencode.jsonc.bak")
+export const getPromptsDir = () => join(BASE, "prompts")

package/src/core/paths.test.js

@@ -0,0 +1,25 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { getConfigDir, getConfigPath, getBackupPath, getPromptsDir } from "./paths.js"
+
+const BASE = join(homedir(), ".config", "opencode")
+
+describe("paths", () => {
+  it("getConfigDir returns ~/.config/opencode", () => {
+    assert.strictEqual(getConfigDir(), BASE)
+  })
+
+  it("getConfigPath returns opencode.jsonc path", () => {
+    assert.strictEqual(getConfigPath(), join(BASE, "opencode.jsonc"))
+  })
+
+  it("getBackupPath returns opencode.jsonc.bak path", () => {
+    assert.strictEqual(getBackupPath(), join(BASE, "opencode.jsonc.bak"))
+  })
+
+  it("getPromptsDir returns prompts path", () => {
+    assert.strictEqual(getPromptsDir(), join(BASE, "prompts"))
+  })
+})

package/src/core/pluginWriter.js

@@ -4,22 +4,26 @@ import { fileURLToPath } from "node:url"
 import { getConfigDir } from "./paths.js"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
-const PLUGIN_NAME = "parent-session.js"
+const PLUGINS = ["pluidr-flow.js", "pluidr-squeeze.js"]
 const PACKAGE_JSON = {
+  type: "module",
   dependencies: { "@opencode-ai/plugin": "^1.17.9" },
 }
 
-export function writePluginBundle() {
-  const pluginsDir = join(getConfigDir(), "plugins")
+export function writePluginBundle(targetDir) {
+  const baseDir = targetDir || getConfigDir()
+  const pluginsDir = join(baseDir, "plugins")
   mkdirSync(pluginsDir, { recursive: true })
 
-  const sourcePath = resolve(__dirname, "../plugins", PLUGIN_NAME)
-  copyFileSync(sourcePath, join(pluginsDir, PLUGIN_NAME))
+  for (const name of PLUGINS) {
+    const sourcePath = resolve(__dirname, "../plugins", name)
+    copyFileSync(sourcePath, join(pluginsDir, name))
+  }
 }
 
-export function writePluginPackageJson() {
-  const packageJsonPath = join(getConfigDir(), "package.json")
-  if (existsSync(packageJsonPath)) return
+export function writePluginPackageJson(targetDir) {
+  const baseDir = targetDir || getConfigDir()
+  const packageJsonPath = join(baseDir, "package.json")
 
   writeFileSync(packageJsonPath, JSON.stringify(PACKAGE_JSON, null, 2), "utf-8")
 }

package/src/core/pluginWriter.test.js

@@ -0,0 +1,41 @@
+import { describe, it, after } from "node:test"
+import assert from "node:assert"
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs"
+import { join, resolve, dirname } from "node:path"
+import { tmpdir } from "node:os"
+import { fileURLToPath } from "node:url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+describe("pluginWriter", () => {
+  const tempDir = mkdtempSync(join(tmpdir(), "pluidr-pluginwriter-"))
+
+  after(() => {
+    if (existsSync(tempDir)) rmSync(tempDir, { recursive: true })
+  })
+
+  it("copies plugin files and writes package.json", async () => {
+    const { writePluginBundle, writePluginPackageJson } = await import("./pluginWriter.js")
+
+    // Use temp dir as target — sandboxed, no real ~/.config/opencode writes
+    writePluginBundle(tempDir)
+
+    const pluginsDestDir = join(tempDir, "plugins")
+    const pluginFiles = ["pluidr-flow.js", "pluidr-squeeze.js"]
+    for (const f of pluginFiles) {
+      assert.ok(existsSync(join(pluginsDestDir, f)),
+        `plugin ${f} should be copied to plugins dir`)
+    }
+
+    // Clean plugins dir to test package.json separately
+    rmSync(pluginsDestDir, { recursive: true })
+
+    writePluginPackageJson(tempDir)
+
+    const pkgPath = join(tempDir, "package.json")
+    assert.ok(existsSync(pkgPath), "package.json should exist in temp dir")
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
+    assert.strictEqual(pkg.type, "module")
+    assert.ok(pkg.dependencies["@opencode-ai/plugin"])
+  })
+})

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")
+  })
+})