pluidr 0.4.1 → 0.6.0

package/src/cli/commands/uninstall.js

@@ -0,0 +1,67 @@
+import { existsSync, copyFileSync, rmSync, readdirSync } from "node:fs"
+import { join, dirname } from "node:path"
+import { getConfigDir, getConfigPath } from "../../core/paths.js"
+
+function findLatestBackup() {
+  const dir = getConfigDir()
+  let backups = []
+  try {
+    backups = readdirSync(dir)
+      .filter((f) => f.startsWith("opencode.jsonc.bak."))
+      .sort()
+      .reverse()
+  } catch {
+    return null
+  }
+  return backups.length > 0 ? join(dir, backups[0]) : null
+}
+
+export async function runUninstall() {
+  const configDir = getConfigDir()
+  const configPath = getConfigPath()
+  const promptsDir = join(configDir, "prompts")
+  const pluginsDir = join(configDir, "plugins")
+  const binDir = join(configDir, "bin")
+
+  const summary = { restored: null, removed: [] }
+
+  // Restore latest backup
+  const latestBackup = findLatestBackup()
+  if (latestBackup && existsSync(configPath)) {
+    copyFileSync(latestBackup, configPath)
+    summary.restored = latestBackup
+  } else if (latestBackup) {
+    // Config doesn't exist but backup does — restore anyway
+    copyFileSync(latestBackup, configPath)
+    summary.restored = latestBackup
+  }
+
+  // Remove Pluidr-installed artifacts
+  if (existsSync(promptsDir)) {
+    rmSync(promptsDir, { recursive: true, force: true })
+    summary.removed.push("prompts/")
+  }
+  if (existsSync(pluginsDir)) {
+    rmSync(pluginsDir, { recursive: true, force: true })
+    summary.removed.push("plugins/")
+  }
+  if (existsSync(binDir)) {
+    rmSync(binDir, { recursive: true, force: true })
+    summary.removed.push("bin/")
+  }
+
+  // Print summary
+  console.log("Uninstall complete:")
+  if (summary.restored) {
+    console.log(`  ✓ Restored ${summary.restored}`)
+  } else {
+    console.log("  - No backup found to restore")
+  }
+  if (summary.removed.length > 0) {
+    console.log(`  ✓ Removed: ${summary.removed.join(", ")}`)
+  } else {
+    console.log("  - No Pluidr artifacts found to remove")
+  }
+  console.log("  - Kept opencode.jsonc (preserves user customizations)")
+  console.log("  - Kept package.json (may be used by other plugins)")
+}

package/src/cli/commands/update.js

@@ -0,0 +1,22 @@
+import { existsSync } from "node:fs"
+import { confirm, isCancel } from "@clack/prompts"
+import { getConfigPath } from "../../core/paths.js"
+import { runInit } from "./init.js"
+
+export async function runUpdate() {
+  const configPath = getConfigPath()
+
+  if (existsSync(configPath)) {
+    const answer = await confirm({
+      message: "Existing Pluidr config found. Overwrite? (Y/n)",
+      initialValue: true,
+    })
+
+    if (isCancel(answer) || !answer) {
+      console.log("Update cancelled.")
+      return
+    }
+  }
+
+  await runInit()
+}

package/src/cli/index.js

@@ -2,13 +2,31 @@ import { readFileSync } from "node:fs"
 import { resolve, dirname } from "node:path"
 import { fileURLToPath } from "node:url"
 import { runInit } from "./commands/init.js"
+import { runUninstall } from "./commands/uninstall.js"
+import { runUpdate } from "./commands/update.js"
+import { runDoctor } from "./commands/doctor.js"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const pkg = JSON.parse(readFileSync(resolve(__dirname, "../../package.json"), "utf-8"))
 
+const HELP = `Usage: pluidr <command>
+
+Commands:
+  init          Set up OpenCode with Pluidr's 12-agent pipeline
+  uninstall     Remove Pluidr artifacts and restore previous config
+  update        Re-run setup (overwrites current config)
+  doctor        Verify installation health
+  --version, -v  Print version number
+  --help, -h     Show this help message`
+
 export function run(argv) {
   const cmd = argv[2]
 
+  if (cmd === "--help" || cmd === "-h") {
+    console.log(HELP)
+    return
+  }
+
   if (cmd === "--version" || cmd === "-v") {
     console.log(pkg.version)
     return
@@ -18,6 +36,18 @@ export function run(argv) {
     return runInit()
   }
 
-  console.log("Usage: pluidr init")
+  if (cmd === "uninstall") {
+    return runUninstall()
+  }
+
+  if (cmd === "update") {
+    return runUpdate()
+  }
+
+  if (cmd === "doctor") {
+    return runDoctor()
+  }
+
+  console.log(HELP)
   process.exit(1)
 }

package/src/cli/wizard/selectModelTier.js

@@ -7,42 +7,33 @@ const TIER_LABELS = {
 
 export async function selectModelTier(modelDefaults) {
   const choices = {}
-
   for (const [tierKey, tierInfo] of Object.entries(modelDefaults)) {
     const defaultModel = `${tierInfo.provider}/${tierInfo.model}`
     const label = TIER_LABELS[tierKey] ?? tierKey
 
-    let selectedModel = defaultModel
-
-    try {
-      const answer = await select({
-        message: label,
-        options: [
-          { value: defaultModel, label: `default (${defaultModel})` },
-          { value: "__custom__", label: "custom  (provider/model)" },
-        ],
-      })
-
-      if (isCancel(answer)) {
-        selectedModel = defaultModel
-      } else if (answer === "__custom__") {
-        try {
-          const customModel = await text({
-            message: "Enter model:",
-          })
-          selectedModel = isCancel(customModel) ? defaultModel : (customModel || defaultModel)
-        } catch {
-          selectedModel = defaultModel
-        }
-      } else {
-        selectedModel = answer
-      }
-    } catch {
-      selectedModel = defaultModel
+    const recommendedOptions = (tierInfo.recommended || []).map((r) => ({
+      value: r.value,
+      label: r.label,
+    }))
+
+    const options = [
+      ...recommendedOptions,
+      { value: "__custom__", label: "custom  (enter provider/model)" },
+    ]
+
+    const answer = await select({
+      message: label,
+      options,
+    })
+
+    if (isCancel(answer)) {
+      choices[tierKey] = defaultModel
+    } else if (answer === "__custom__") {
+      const customModel = await text({ message: "Enter model:" })
+      choices[tierKey] = isCancel(customModel) ? defaultModel : (customModel || defaultModel)
+    } else {
+      choices[tierKey] = answer
     }
-
-    choices[tierKey] = selectedModel
   }
-
   return choices
 }

package/src/core/agentPromptWriter.js

@@ -8,9 +8,9 @@ import IDENTITY_HEADER from "./identityHeader.js"
 // copied verbatim — no agent-identity header.
 const REFERENCE_FILES = new Set(["hierarchy"])
 
-export function writeAgentPrompts(templatesDir) {
+export function writeAgentPrompts(templatesDir, destDir) {
   const sourceDir = resolve(templatesDir, "agent-prompts")
-  const destDir = getPromptsDir()
+  if (!destDir) destDir = getPromptsDir()
 
   mkdirSync(destDir, { recursive: true })
 

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, "compose-reporter.txt"), "write docs", "utf-8")
+
+    writeAgentPrompts(tmpDir, destDir)
+
+    const coderContent = readFileSync(join(destDir, "coder.txt"), "utf-8")
+    const composeReporterContent = readFileSync(join(destDir, "compose-reporter.txt"), "utf-8")
+
+    assert.ok(coderContent.startsWith('You are the "coder" agent.\n\n'),
+      "coder should have identity header")
+    assert.ok(composeReporterContent.startsWith('You are the "compose-reporter" agent.\n\n'),
+      "compose-reporter should have identity header")
+    assert.ok(coderContent.includes("test instructions"),
+      "original content preserved in coder")
+    assert.ok(composeReporterContent.includes("write docs"),
+      "original content preserved in compose-reporter")
+
+    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() {
+  // ponytail: simplified formatting using native Date serialization
+  const s = new Date().toISOString().replace(/[-:]/g, "")
+  return `${s.slice(0, 8)}_${s.slice(9, 15)}`
+}
+
+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 getPromptsDir = () => join(BASE, "prompts")
+// ponytail: getBackupPath removed (YAGNI)

package/src/core/paths.test.js

@@ -0,0 +1,21 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { getConfigDir, getConfigPath, 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("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"])
+  })
+})