@funara/wevr 0.1.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(), "wevr-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/backup.js

@@ -0,0 +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)
+  }
+}

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(), "wevr-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/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(), "wevr-command-dest-"))
+
+  after(() => {
+    if (existsSync(destDir)) rmSync(destDir, { recursive: true })
+  })
+
+  it("copies command files to destination directory", () => {
+    const tmpSrcDir = mkdtempSync(join(tmpdir(), "wevr-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

@@ -0,0 +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
+}

package/src/core/configBuilder.test.js

@@ -0,0 +1,93 @@
+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: {
+        compose: {},
+        verifier: {},
+        builder: {},
+      },
+    }
+    const defaultsJson = {
+      reasoning: {
+        provider: "test",
+        model: "big-model",
+        agents: ["compose"],
+      },
+      precision: {
+        provider: "test",
+        model: "mid-model",
+        agents: ["verifier"],
+      },
+      fast: {
+        provider: "test",
+        model: "small-model",
+        agents: ["builder"],
+      },
+    }
+
+    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(
+      {
+        reasoning: "test/big-model",
+        precision: "test/mid-model",
+        fast: "test/small-model",
+      },
+      tmpDir,
+    )
+
+    assert.strictEqual(result.agent.compose.model, "test/big-model")
+    assert.strictEqual(result.agent.verifier.model, "test/mid-model")
+    assert.strictEqual(result.agent.builder.model, "test/small-model")
+
+    rmSync(tmpDir, { recursive: true })
+  })
+
+  it("throws an error if a defaulted agent is missing from config template", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "configbuilder-test-err-"))
+
+    const configJson = {
+      agent: {
+        // missing 'compose'
+        builder: {},
+      },
+    }
+    const defaultsJson = {
+      reasoning: {
+        provider: "test",
+        model: "big-model",
+        agents: ["compose"],
+      },
+      fast: {
+        provider: "test",
+        model: "small-model",
+        agents: ["builder"],
+      },
+    }
+
+    writeFileSync(join(tmpDir, "opencode.config.json"), JSON.stringify(configJson), "utf-8")
+    writeFileSync(join(tmpDir, "model-defaults.json"), JSON.stringify(defaultsJson), "utf-8")
+
+    assert.throws(() => {
+      buildConfig(
+        {
+          reasoning: "test/big-model",
+          fast: "test/small-model",
+        },
+        tmpDir,
+      )
+    }, /Template validation failed: agent\(s\) not found/)
+
+    rmSync(tmpDir, { recursive: true })
+  })
+})

package/src/core/configWriter.js

@@ -0,0 +1,10 @@
+import { mkdirSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { getConfigDir } from "./paths.js"
+
+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(), "wevr-configwriter-"))
+
+  after(() => {
+    if (existsSync(tempDir)) rmSync(tempDir, { recursive: true })
+  })
+
+  it("writes config as formatted JSON to the correct path", () => {
+    const configObj = { agent: { compose: { 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.js

@@ -0,0 +1,8 @@
+// Single source of truth for the agent identity prefix prepended to every
+// generated prompt file. Mirrors the system identity concept from the
+// dropped hook-based AgentSelfIdentityPlugin, but as a static prepend
+// (KISS: agent names are known at install time).
+
+export default function IDENTITY_HEADER(agentName) {
+  return `You are the "${agentName}" agent.\n\n`
+}

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

@@ -0,0 +1,13 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+const BASE = join(homedir(), ".config", "opencode")
+
+export const getConfigDir = () => BASE
+export const getConfigPath = () => join(BASE, "opencode.jsonc")
+export const getTuiConfigPath = () => join(BASE, "tui.json")
+export const getPromptsDir = () => join(BASE, "prompts")
+export const getThemesDir = () => join(BASE, "themes")
+export const getSkillsDir = () => join(BASE, "skills")
+export const getCommandsDir = () => join(BASE, "commands")
+// ponytail: getBackupPath removed (YAGNI)

package/src/core/paths.test.js

@@ -0,0 +1,33 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { getConfigDir, getConfigPath, getTuiConfigPath, getPromptsDir, getThemesDir, getSkillsDir } 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("getTuiConfigPath returns tui.json path", () => {
+    assert.strictEqual(getTuiConfigPath(), join(BASE, "tui.json"))
+  })
+
+  it("getPromptsDir returns prompts path", () => {
+    assert.strictEqual(getPromptsDir(), join(BASE, "prompts"))
+  })
+
+  it("getThemesDir returns themes path", () => {
+    assert.strictEqual(getThemesDir(), join(BASE, "themes"))
+  })
+
+  it("getSkillsDir returns skills path", () => {
+    assert.strictEqual(getSkillsDir(), join(BASE, "skills"))
+  })
+})

package/src/core/pluginWriter.js

@@ -0,0 +1,29 @@
+import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { getConfigDir } from "./paths.js"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const PLUGINS = ["wevr-flow.js", "wevr-squeeze.js"]
+const PACKAGE_JSON = {
+  type: "module",
+  dependencies: { "@opencode-ai/plugin": "^1.17.9" },
+}
+
+export function writePluginBundle(targetDir) {
+  const baseDir = targetDir || getConfigDir()
+  const pluginsDir = join(baseDir, "plugins")
+  mkdirSync(pluginsDir, { recursive: true })
+
+  for (const name of PLUGINS) {
+    const sourcePath = resolve(__dirname, "../plugins", name)
+    copyFileSync(sourcePath, join(pluginsDir, name))
+  }
+}
+
+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(), "wevr-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 = ["wevr-flow.js", "wevr-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/skillsWriter.js

@@ -0,0 +1,13 @@
+import { mkdirSync, cpSync, existsSync } from "node:fs"
+import { resolve } from "node:path"
+import { getSkillsDir } from "./paths.js"
+
+export function writeSkills(templatesDir, destDir) {
+  const sourcePath = resolve(templatesDir, "skills")
+  const targetDir = destDir || getSkillsDir()
+
+  mkdirSync(targetDir, { recursive: true })
+  if (existsSync(sourcePath)) {
+    cpSync(sourcePath, targetDir, { recursive: true })
+  }
+}

package/src/core/skillsWriter.test.js

@@ -0,0 +1,30 @@
+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 { writeSkills } from "./skillsWriter.js"
+
+describe("skillsWriter", () => {
+  const destDir = mkdtempSync(join(tmpdir(), "wevr-skills-dest-"))
+
+  after(() => {
+    if (existsSync(destDir)) rmSync(destDir, { recursive: true })
+  })
+
+  it("copies skills directories recursively to destination directory", () => {
+    const tmpSrcDir = mkdtempSync(join(tmpdir(), "wevr-skills-src-"))
+    const srcSkillsDir = join(tmpSrcDir, "skills")
+    const testSkillDir = join(srcSkillsDir, "test-skill")
+    mkdirSync(testSkillDir, { recursive: true })
+    writeFileSync(join(testSkillDir, "SKILL.md"), "mock-skill-content", "utf-8")
+
+    writeSkills(tmpSrcDir, destDir)
+
+    const destPath = join(destDir, "test-skill", "SKILL.md")
+    assert.ok(existsSync(destPath), "SKILL.md should be copied recursively")
+    assert.strictEqual(readFileSync(destPath, "utf-8"), "mock-skill-content")
+
+    rmSync(tmpSrcDir, { recursive: true })
+  })
+})

package/src/core/themeWriter.js

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

package/src/core/themeWriter.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 { writeThemes } from "./themeWriter.js"
+
+describe("themeWriter", () => {
+  const destDir = mkdtempSync(join(tmpdir(), "wevr-theme-dest-"))
+
+  after(() => {
+    if (existsSync(destDir)) rmSync(destDir, { recursive: true })
+  })
+
+  it("copies theme file to destination directory", () => {
+    const tmpSrcDir = mkdtempSync(join(tmpdir(), "wevr-theme-src-"))
+    const srcThemesDir = join(tmpSrcDir, "themes")
+    mkdirSync(srcThemesDir, { recursive: true })
+    writeFileSync(join(srcThemesDir, "wevr-dark.json"), "mock-theme-content", "utf-8")
+
+    writeThemes(tmpSrcDir, destDir)
+
+    const destPath = join(destDir, "wevr-dark.json")
+    assert.ok(existsSync(destPath), "theme file should be copied")
+    assert.strictEqual(readFileSync(destPath, "utf-8"), "mock-theme-content")
+
+    rmSync(tmpSrcDir, { recursive: true })
+  })
+})

package/src/core/tuiConfigWriter.js

@@ -0,0 +1,22 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs"
+import { getTuiConfigPath } from "./paths.js"
+
+export function writeTuiConfig(themeName, customPath) {
+  const path = customPath || getTuiConfigPath()
+  let config = {
+    "$schema": "https://opencode.ai/tui.json"
+  }
+
+  if (existsSync(path)) {
+    try {
+      const content = readFileSync(path, "utf-8")
+      config = JSON.parse(content)
+    } catch {
+      // If parsing fails, fall back to default structure
+    }
+  }
+
+  config.theme = themeName
+
+  writeFileSync(path, JSON.stringify(config, null, 2), "utf-8")
+}