pluidr 0.7.5 → 0.8.0

package/src/core/agentPromptWriter.test.js

@@ -1,56 +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 })
-  })
-})
+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, "builder.txt"), "test instructions", "utf-8")
+    writeFileSync(join(agentPromptsDir, "reporter.txt"), "write docs", "utf-8")
+
+    writeAgentPrompts(tmpDir, destDir)
+
+    const coderContent = readFileSync(join(destDir, "builder.txt"), "utf-8")
+    const composeReporterContent = readFileSync(join(destDir, "reporter.txt"), "utf-8")
+
+    assert.ok(coderContent.startsWith('You are the "builder" agent.\n\n'),
+      "builder should have identity header")
+    assert.ok(composeReporterContent.startsWith('You are the "reporter" agent.\n\n'),
+      "reporter should have identity header")
+    assert.ok(coderContent.includes("test instructions"),
+      "original content preserved in builder")
+    assert.ok(composeReporterContent.includes("write docs"),
+      "original content preserved in 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/animation.js

@@ -0,0 +1,83 @@
+import fs from "node:fs"
+import { getTuiConfigPath } from "./paths.js"
+
+export const COLORS = [
+  "\x1b[38;2;0;225;255m",  // Bright Cyan
+  "\x1b[38;2;0;200;250m",  // Ocean Blue
+  "\x1b[38;2;50;150;250m",  // Soft Blue-Purple
+  "\x1b[38;2;120;120;255m", // Indigo-Purple
+  "\x1b[38;2;180;90;255m"   // Purple
+]
+
+export const ASCII_LOGO_LINES = [
+  " ██████   ██      ██   ██   ██  ███████   ███████ ",
+  " ██   ██  ██      ██   ██   ██  ██    ██  ██    ██",
+  " ██████   ██      ██   ██   ██  ██    ██  ███████ ",
+  " ██       ██      ██   ██   ██  ██    ██  ██   ██ ",
+  " ██       ███████  █████    ██  ███████   ██    ██"
+]
+
+export function getAnimationType() {
+  // 1. Check command line args
+  const argv = process.argv
+  const animIndex = argv.indexOf("--animation")
+  if (animIndex !== -1 && animIndex + 1 < argv.length) {
+    const val = argv[animIndex + 1].toLowerCase()
+    if (["float", "wave", "pulse", "none"].includes(val)) {
+      return val
+    }
+  }
+
+  // 2. Check env variable
+  if (process.env.PLUIDR_ANIMATION) {
+    const val = process.env.PLUIDR_ANIMATION.toLowerCase()
+    if (["float", "wave", "pulse", "none"].includes(val)) {
+      return val
+    }
+  }
+
+  // 3. Check tui.json
+  const path = getTuiConfigPath()
+  if (fs.existsSync(path)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(path, "utf-8"))
+      if (config.animation) {
+        const val = config.animation.toLowerCase()
+        if (["float", "wave", "pulse", "none"].includes(val)) {
+          return val
+        }
+      }
+    } catch {
+      // Ignore
+    }
+  }
+
+  return "wave" // default to wave
+}
+
+export function getLogoLine(line, r, frame, type) {
+  let offset = 3
+  let colorIndex = (frame + r) % COLORS.length
+
+  switch (type) {
+    case "wave":
+      offset = Math.round(3 + 2 * Math.sin(frame / 3.5 - r * 0.8))
+      break
+    case "float":
+      offset = Math.round(3 + 2 * Math.sin(frame / 3.5))
+      break
+    case "pulse":
+      offset = 3
+      colorIndex = frame % COLORS.length
+      break
+    case "none":
+      offset = 3
+      colorIndex = r % COLORS.length
+      break
+  }
+
+  return {
+    text: " ".repeat(offset) + line,
+    color: COLORS[colorIndex]
+  }
+}

package/src/core/animation.test.js

@@ -0,0 +1,118 @@
+import { describe, it, before, after, beforeEach, afterEach, mock } from "node:test"
+import assert from "node:assert"
+import fs from "node:fs"
+import { getAnimationType, getLogoLine, COLORS, ASCII_LOGO_LINES } from "./animation.js"
+
+describe("animation utility", () => {
+  let originalArgv
+  let originalEnv
+
+  before(() => {
+    originalArgv = [...process.argv]
+    originalEnv = { ...process.env }
+  })
+
+  after(() => {
+    process.argv = originalArgv
+    process.env = originalEnv
+  })
+
+  beforeEach(() => {
+    // Clear animation env and argv for clean start
+    delete process.env.PLUIDR_ANIMATION
+    process.argv = [originalArgv[0], originalArgv[1]]
+  })
+
+  afterEach(() => {
+    mock.reset()
+  })
+
+  describe("getAnimationType", () => {
+    it("should return wave as the default when no configs are present", () => {
+      // Mock existsSync to return false for tui.json
+      mock.method(fs, "existsSync", () => false)
+
+      const type = getAnimationType()
+      assert.strictEqual(type, "wave")
+    })
+
+    it("should prioritize CLI argument over others", () => {
+      mock.method(fs, "existsSync", () => true)
+      mock.method(fs, "readFileSync", () => JSON.stringify({ animation: "float" }))
+
+      process.env.PLUIDR_ANIMATION = "none"
+      process.argv.push("--animation", "pulse")
+
+      const type = getAnimationType()
+      assert.strictEqual(type, "pulse")
+    })
+
+    it("should prioritize env variable over tui.json", () => {
+      mock.method(fs, "existsSync", () => true)
+      mock.method(fs, "readFileSync", () => JSON.stringify({ animation: "float" }))
+
+      process.env.PLUIDR_ANIMATION = "none"
+
+      const type = getAnimationType()
+      assert.strictEqual(type, "none")
+    })
+
+    it("should fallback to default wave if config has invalid animation type", () => {
+      mock.method(fs, "existsSync", () => true)
+      mock.method(fs, "readFileSync", () => JSON.stringify({ animation: "invalid_type_abc" }))
+
+      const type = getAnimationType()
+      assert.strictEqual(type, "wave")
+    })
+
+    it("should read animation type from tui.json if no CLI/env configs are set", () => {
+      mock.method(fs, "existsSync", () => true)
+      mock.method(fs, "readFileSync", () => JSON.stringify({ animation: "float" }))
+
+      const type = getAnimationType()
+      assert.strictEqual(type, "float")
+    })
+  })
+
+  describe("getLogoLine", () => {
+    const sampleLine = "TEST_LINE"
+
+    it("renders float animation with horizontal synchronization", () => {
+      const frame = 0
+      const r = 0
+      const res = getLogoLine(sampleLine, r, frame, "float")
+
+      assert.ok(res.text.includes(sampleLine))
+      assert.strictEqual(res.color, COLORS[0])
+    })
+
+    it("renders wave animation with row-skewed offsets", () => {
+      const frame = 5
+      const r = 2
+      const res = getLogoLine(sampleLine, r, frame, "wave")
+
+      assert.ok(res.text.includes(sampleLine))
+      assert.strictEqual(res.color, COLORS[(frame + r) % COLORS.length])
+    })
+
+    it("renders pulse animation with static offset but pulsing color", () => {
+      const frame = 3
+      const r = 1
+      const res = getLogoLine(sampleLine, r, frame, "pulse")
+
+      // Pulse maintains a static offset of 3 spaces
+      assert.strictEqual(res.text, "   " + sampleLine)
+      assert.strictEqual(res.color, COLORS[frame % COLORS.length])
+    })
+
+    it("renders none animation with static offset and static gradient colors", () => {
+      const frame = 10
+      const r = 3
+      const res = getLogoLine(sampleLine, r, frame, "none")
+
+      // None maintains static offset of 3 spaces
+      assert.strictEqual(res.text, "   " + sampleLine)
+      assert.strictEqual(res.color, COLORS[r % COLORS.length])
+    })
+  })
+})

package/src/core/backup.js

@@ -1,46 +1,46 @@
-import { existsSync, copyFileSync, readdirSync, unlinkSync } from "node:fs"
-import { join, dirname } from "node:path"
-import { getConfigPath, getTuiConfigPath } from "./paths.js"
-
-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 (err) {
-    if (err.code !== "ENOENT") throw err
-  }
-
-  while (backups.length >= MAX_BACKUPS) {
-    const oldest = backups.shift()
-    try { unlinkSync(oldest) } catch {}
-  }
-}
-
-export function backupExistingConfig(configPath) {
-  const resolvedPath = configPath || getConfigPath()
-  if (existsSync(resolvedPath)) {
-    rotateBackups(resolvedPath)
-    const backupPath = `${resolvedPath}.bak.${timestamp()}`
-    copyFileSync(resolvedPath, backupPath)
-  }
-
-  const tuiPath = getTuiConfigPath()
-  if (existsSync(tuiPath)) {
-    const backupTuiPath = `${tuiPath}.bak.${timestamp()}`
-    copyFileSync(tuiPath, backupTuiPath)
-  }
-}
+import { existsSync, copyFileSync, readdirSync, unlinkSync } from "node:fs"
+import { join, dirname } from "node:path"
+import { getConfigPath, getTuiConfigPath } from "./paths.js"
+
+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 (err) {
+    if (err.code !== "ENOENT") throw err
+  }
+
+  while (backups.length >= MAX_BACKUPS) {
+    const oldest = backups.shift()
+    try { unlinkSync(oldest) } catch {}
+  }
+}
+
+export function backupExistingConfig(configPath) {
+  const resolvedPath = configPath || getConfigPath()
+  if (existsSync(resolvedPath)) {
+    rotateBackups(resolvedPath)
+    const backupPath = `${resolvedPath}.bak.${timestamp()}`
+    copyFileSync(resolvedPath, backupPath)
+  }
+
+  const tuiPath = getTuiConfigPath()
+  if (existsSync(tuiPath)) {
+    const backupTuiPath = `${tuiPath}.bak.${timestamp()}`
+    copyFileSync(tuiPath, backupTuiPath)
+  }
+}

package/src/core/commandsWriter.js

@@ -0,0 +1,26 @@
+import { mkdirSync, cpSync, existsSync, readdirSync, unlinkSync } from "node:fs"
+import { resolve } from "node:path"
+import { getCommandsDir } from "./paths.js"
+
+export function writeCommands(templatesDir, destDir) {
+  const sourcePath = resolve(templatesDir, "commands")
+  const targetDir = destDir || getCommandsDir()
+
+  // Clear any existing .md files in targetDir to prevent stale commands
+  if (existsSync(targetDir)) {
+    try {
+      for (const file of readdirSync(targetDir)) {
+        if (file.endsWith(".md")) {
+          unlinkSync(resolve(targetDir, file))
+        }
+      }
+    } catch {
+      // Ignore
+    }
+  }
+
+  mkdirSync(targetDir, { recursive: true })
+  if (existsSync(sourcePath)) {
+    cpSync(sourcePath, targetDir, { recursive: true })
+  }
+}

package/src/core/commandsWriter.test.js

@@ -0,0 +1,29 @@
+import { describe, it, after } from "node:test"
+import assert from "node:assert"
+import { existsSync, mkdtempSync, readFileSync, rmSync, mkdirSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { writeCommands } from "./commandsWriter.js"
+
+describe("commandsWriter", () => {
+  const destDir = mkdtempSync(join(tmpdir(), "pluidr-command-dest-"))
+
+  after(() => {
+    if (existsSync(destDir)) rmSync(destDir, { recursive: true })
+  })
+
+  it("copies command files to destination directory", () => {
+    const tmpSrcDir = mkdtempSync(join(tmpdir(), "pluidr-command-src-"))
+    const srcCommandsDir = join(tmpSrcDir, "commands")
+    mkdirSync(srcCommandsDir, { recursive: true })
+    writeFileSync(join(srcCommandsDir, "squeeze-quick.md"), "mock-command-content", "utf-8")
+
+    writeCommands(tmpSrcDir, destDir)
+
+    const destPath = join(destDir, "squeeze-quick.md")
+    assert.ok(existsSync(destPath), "command file should be copied")
+    assert.strictEqual(readFileSync(destPath, "utf-8"), "mock-command-content")
+
+    rmSync(tmpSrcDir, { recursive: true })
+  })
+})

package/src/core/configBuilder.js

@@ -1,32 +1,32 @@
-import { readFileSync } from "node:fs"
-import { resolve } from "node:path"
-
-export function buildConfig(tierChoices, templatesDir) {
-  const configPath = resolve(templatesDir, "opencode.config.json")
-  const defaultsPath = resolve(templatesDir, "model-defaults.json")
-
-  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) {
-      config.agent[agentName].model = model
-    }
-  }
-
-  return config
-}
+import { readFileSync } from "node:fs"
+import { resolve } from "node:path"
+
+export function buildConfig(tierChoices, templatesDir) {
+  const configPath = resolve(templatesDir, "opencode.config.json")
+  const defaultsPath = resolve(templatesDir, "model-defaults.json")
+
+  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) {
+      config.agent[agentName].model = model
+    }
+  }
+
+  return config
+}