@otto-assistant/otto 0.1.0

package/src/health.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest"
+import {
+  checkPackagePresence,
+  checkConfigHealth,
+  checkDirectoryHealth,
+} from "./health.js"
+
+describe("health", () => {
+  it("checkPackagePresence returns results for all manifest packages", { timeout: 30_000 }, () => {
+    const results = checkPackagePresence()
+    expect(results).toHaveLength(2) // opencode-ai + kimaki (not opencode-agent-memory — it's a plugin)
+    for (const r of results) {
+      expect(r).toHaveProperty("name")
+      expect(r).toHaveProperty("installed")
+      expect(r).toHaveProperty("status")
+    }
+  })
+
+  it("checkConfigHealth returns structured result", () => {
+    const result = checkConfigHealth()
+    expect(result).toHaveProperty("opencodeJson")
+    expect(result).toHaveProperty("ottoJson")
+    expect(result).toHaveProperty("agentMemoryJson")
+    expect(result).toHaveProperty("memoryPluginEnabled")
+    expect(result).toHaveProperty("subagentPolicyInjected")
+    expect(result).toHaveProperty("subagentThreadsEnabled")
+    expect(result).toHaveProperty("subagentThreadsAskBeforeDelete")
+    expect(result).toHaveProperty("subagentThreadsAutoDelete")
+    expect(result).toHaveProperty("plugins")
+    expect(result).toHaveProperty("kimakiRunning")
+    expect(Array.isArray(result.plugins)).toBe(true)
+  })
+
+  it("checkDirectoryHealth returns results", () => {
+    const results = checkDirectoryHealth()
+    expect(Array.isArray(results)).toBe(true)
+    expect(results.length).toBeGreaterThan(0)
+  })
+})

package/src/health.ts

@@ -0,0 +1,114 @@
+import fs from "node:fs"
+import path from "node:path"
+import { getInstalledVersion } from "./detect.js"
+import { readOpenCodeConfigState, readOttoConfig, type OpenCodeConfig } from "./config.js"
+import { MANIFEST, OPENCODE_CONFIG_DIR, KIMAKI_DATA_DIR } from "./manifest.js"
+import { isKimakiRunning } from "./lifecycle.js"
+
+export interface HealthResult {
+  name: string
+  status: "ok" | "warn" | "error"
+  message: string
+}
+
+export interface PackageCheck {
+  name: string
+  installed: string | null
+  required: string
+  status: "ok" | "missing"
+}
+
+const SUBAGENT_POLICY_MARKER = "Otto subagent policy (must follow):"
+
+function subagentPolicyInjectedInPrompts(config: OpenCodeConfig): boolean {
+  const agent = config.agent
+  if (!agent || typeof agent !== "object" || Array.isArray(agent)) {
+    return false
+  }
+  for (const value of Object.values(agent as Record<string, unknown>)) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const prompt = (value as { prompt?: unknown }).prompt
+      if (typeof prompt === "string" && prompt.includes(SUBAGENT_POLICY_MARKER)) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+export function checkPackagePresence(): PackageCheck[] {
+  return Object.entries(MANIFEST.packages).map(([name, required]) => {
+    const installed = getInstalledVersion(name)
+    return { name, installed, required, status: installed ? ("ok" as const) : ("missing" as const) }
+  })
+}
+
+export interface ConfigHealth {
+  opencodeJson: "ok" | "missing" | "error"
+  ottoJson: "ok" | "missing"
+  agentMemoryJson: "ok" | "missing"
+  memoryPluginEnabled: boolean
+  subagentPolicyInjected: boolean
+  subagentThreadsEnabled: boolean
+  subagentThreadsAskBeforeDelete: boolean
+  subagentThreadsAutoDelete: boolean
+  plugins: string[]
+  kimakiRunning: boolean
+}
+
+export function checkConfigHealth(): ConfigHealth {
+  const configDir = OPENCODE_CONFIG_DIR()
+  const agentMemoryPath = path.join(configDir, "agent-memory.json")
+  const ottoJsonPath = path.join(configDir, "otto.json")
+
+  const state = readOpenCodeConfigState()
+  const opencodeJson: ConfigHealth["opencodeJson"] =
+    state.status === "missing" ? "missing" : state.status === "invalid" ? "error" : "ok"
+  const agentMemoryJson: ConfigHealth["agentMemoryJson"] = fs.existsSync(agentMemoryPath) ? "ok" : "missing"
+  const ottoJson: ConfigHealth["ottoJson"] = fs.existsSync(ottoJsonPath) ? "ok" : "missing"
+
+  const config = state.status === "ok" ? state.config : {}
+  const configuredPlugins = config.plugin ?? []
+  const memoryPluginEnabled = configuredPlugins.includes("opencode-agent-memory")
+
+  const subagentPolicyInjected = subagentPolicyInjectedInPrompts(config)
+
+  // Read Otto config from otto.json (separate from opencode.json)
+  const ottoConfig = readOttoConfig()
+  const subagentThreadsEnabled = ottoConfig.subagentThreads.enabled
+  const subagentThreadsAskBeforeDelete = ottoConfig.subagentThreads.askBeforeDelete
+  const subagentThreadsAutoDelete = ottoConfig.subagentThreads.autoDeleteOnComplete
+  const kimakiRunning = isKimakiRunning()
+
+  return {
+    opencodeJson,
+    ottoJson,
+    agentMemoryJson,
+    memoryPluginEnabled,
+    subagentPolicyInjected,
+    subagentThreadsEnabled,
+    subagentThreadsAskBeforeDelete,
+    subagentThreadsAutoDelete,
+    plugins: configuredPlugins,
+    kimakiRunning,
+  }
+}
+
+export function checkDirectoryHealth(): HealthResult[] {
+  const results: HealthResult[] = []
+  const dirs = [
+    { p: OPENCODE_CONFIG_DIR(), label: "opencode config dir" },
+    { p: path.join(OPENCODE_CONFIG_DIR(), "memory"), label: "opencode memory dir" },
+    { p: path.join(OPENCODE_CONFIG_DIR(), "journal"), label: "opencode journal dir" },
+    { p: KIMAKI_DATA_DIR(), label: "kimaki data dir" },
+  ]
+
+  for (const { p, label } of dirs) {
+    if (fs.existsSync(p)) {
+      results.push({ name: label, status: "ok", message: `exists: ${p}` })
+    } else {
+      results.push({ name: label, status: "warn", message: `missing: ${p}` })
+    }
+  }
+  return results
+}

package/src/index.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from "vitest";
+import { ottoVersion } from "./index.js";
+
+describe("otto", () => {
+  it("returns version string", () => {
+    expect(ottoVersion()).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+});

package/src/index.ts

@@ -0,0 +1,28 @@
+import { MANIFEST } from "./manifest.js"
+
+export function ottoVersion(): string {
+  return MANIFEST.version
+}
+
+export { MANIFEST, OPENCODE_CONFIG_DIR, KIMAKI_DATA_DIR } from "./manifest.js"
+export { getInstalledVersion, detectPackage } from "./detect.js"
+export type { InstalledPackage } from "./detect.js"
+export {
+  mergePlugins,
+  readOttoConfig,
+  writeOttoConfig,
+  OTTO_DEFAULTS,
+  buildSubagentThreadPolicy,
+  mergeAgentPrompts,
+  ensureSubagentThreadSkill,
+  readOpenCodeConfig,
+  readOpenCodeConfigState,
+  writeOpenCodeConfig,
+  ensureAgentMemoryConfig,
+} from "./config.js"
+export type { OpenCodeConfig, OttoConfig, OttoSubagentThreads, OttoConfigReadStatus, OpenCodeConfigReadStatus } from "./config.js"
+export { installPackage, upgradePackage, installMissingPackages, planStableUpgrades } from "./installer.js"
+export type { UpgradeMode } from "./installer.js"
+export { hasKimakiBinary, isKimakiRunning, restartKimaki } from "./lifecycle.js"
+export { checkPackagePresence, checkConfigHealth, checkDirectoryHealth } from "./health.js"
+export type { HealthResult, PackageCheck, ConfigHealth } from "./health.js"

package/src/installer.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest"
+import { installMissingPackages, planStableUpgrades } from "./installer.js"
+
+describe("installer", () => {
+  it("installMissingPackages returns empty when all installed", () => {
+    const getInstalled = (_name: string) => "1.0.0"
+    const installed = installMissingPackages(getInstalled, () => "ok")
+    expect(installed).toEqual([])
+  })
+
+  it("installMissingPackages returns missing package names", () => {
+    const getInstalled = (name: string) => name === "kimaki" ? "1.0.0" : null
+    const installedNames: string[] = []
+    const install = (name: string) => { installedNames.push(name); return name }
+
+    const result = installMissingPackages(getInstalled, install)
+
+    expect(result).toContain("opencode-ai")
+    expect(result).not.toContain("kimaki")
+    // opencode-agent-memory is a plugin, not a global npm package
+    expect(result).not.toContain("opencode-agent-memory")
+  })
+
+  it("planStableUpgrades returns empty when all packages match pinned", () => {
+    const pinned = { a: "1.0.0", b: "2.0.0" }
+    const getInstalled = (name: string) => pinned[name as keyof typeof pinned] ?? null
+    const plan = planStableUpgrades(["a", "b"], getInstalled, pinned)
+    expect(plan).toEqual([])
+  })
+
+  it("planStableUpgrades lists packages whose version differs from pinned", () => {
+    const pinned = { "opencode-ai": "1.2.20", kimaki: "0.4.90" }
+    const getInstalled = (name: string) => (name === "kimaki" ? "0.4.90" : "1.0.0")
+    const plan = planStableUpgrades(["opencode-ai", "kimaki"], getInstalled, pinned)
+    expect(plan).toEqual([
+      { name: "opencode-ai", current: "1.0.0", target: "1.2.20" },
+    ])
+  })
+
+  it("planStableUpgrades includes not installed packages", () => {
+    const pinned = { x: "1.0.0" }
+    const getInstalled = () => null as string | null
+    const plan = planStableUpgrades(["x"], getInstalled, pinned)
+    expect(plan).toEqual([{ name: "x", current: null, target: "1.0.0" }])
+  })
+
+  it("planStableUpgrades throws when pinned entry missing for a package", () => {
+    expect(() =>
+      planStableUpgrades(["missing"], () => "1.0.0", {}),
+    ).toThrow("No pinned version for missing in manifest")
+  })
+})

package/src/installer.ts

@@ -0,0 +1,62 @@
+import { execSync } from "node:child_process"
+import { MANIFEST } from "./manifest.js"
+
+export type UpgradeMode = "stable" | "latest"
+
+export function installPackage(name: string, version?: string): string {
+  const spec = version ? `${name}@${version}` : name
+  execSync(`npm install -g ${spec}`, {
+    encoding: "utf-8",
+    stdio: "pipe",
+  })
+  return spec
+}
+
+export function upgradePackage(name: string, mode: UpgradeMode): string {
+  if (mode === "stable") {
+    const pinned = MANIFEST.pinned[name]
+    if (!pinned) {
+      throw new Error(`No pinned version for ${name} in manifest`)
+    }
+    return installPackage(name, pinned)
+  }
+  return installPackage(name, "latest")
+}
+
+export function planStableUpgrades(
+  packageNames: string[],
+  getInstalled: (name: string) => string | null,
+  pinned: Record<string, string>,
+): { name: string; current: string | null; target: string }[] {
+  const upgrades: { name: string; current: string | null; target: string }[] = []
+  for (const name of packageNames) {
+    const target = pinned[name]
+    if (!target) {
+      throw new Error(`No pinned version for ${name} in manifest`)
+    }
+    const current = getInstalled(name)
+    if (current !== target) {
+      upgrades.push({ name, current, target })
+    }
+  }
+  return upgrades
+}
+
+export function installMissingPackages(
+  getInstalled: (name: string) => string | null,
+  install: (name: string, version?: string) => string = installPackage,
+): string[] {
+  const installed: string[] = []
+  for (const name of Object.keys(MANIFEST.packages)) {
+    const current = getInstalled(name)
+    if (!current) {
+      const pinned = MANIFEST.pinned[name]
+      if (!pinned) {
+        throw new Error(`No pinned version for ${name} in manifest`)
+      }
+      install(name, pinned)
+      installed.push(name)
+    }
+  }
+  return installed
+}

package/src/lifecycle.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest"
+import { hasKimakiBinary, isKimakiRunning, restartKimaki } from "./lifecycle.js"
+
+describe("lifecycle", () => {
+  it("hasKimakiBinary returns boolean", () => {
+    const result = hasKimakiBinary()
+    expect(typeof result).toBe("boolean")
+  })
+
+  it("isKimakiRunning returns boolean", () => {
+    const result = isKimakiRunning()
+    expect(typeof result).toBe("boolean")
+  })
+
+  it("restartKimaki is a function", () => {
+    expect(typeof restartKimaki).toBe("function")
+  })
+
+  it("restartKimaki throws descriptive error when kimaki not found", () => {
+    expect(typeof restartKimaki).toBe("function")
+  })
+})

package/src/lifecycle.ts

@@ -0,0 +1,30 @@
+import { execSync } from "node:child_process"
+
+export function hasKimakiBinary(): boolean {
+  try {
+    execSync("which kimaki", { encoding: "utf-8", stdio: "pipe" })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function isKimakiRunning(): boolean {
+  try {
+    const output = execSync("pgrep -f kimaki", { encoding: "utf-8", stdio: "pipe" })
+    return output.trim().length > 0
+  } catch {
+    return false
+  }
+}
+
+export function restartKimaki(): void {
+  if (!hasKimakiBinary()) {
+    throw new Error("kimaki is not installed. Install it first with: npm install -g kimaki")
+  }
+  execSync("kimaki restart", {
+    encoding: "utf-8",
+    stdio: "pipe",
+    timeout: 30_000,
+  })
+}

package/src/manifest.ts

@@ -0,0 +1,42 @@
+export interface Manifest {
+  version: string
+  /** Packages installed globally via npm (CLI tools) */
+  packages: Record<string, string>
+  /** Pinned versions for `otto upgrade stable` (global npm packages only) */
+  pinned: Record<string, string>
+  /** Plugins enabled via opencode.json plugin[] — opencode resolves them itself */
+  plugins: string[]
+}
+
+export const MANIFEST: Manifest = {
+  version: "0.1.0",
+  packages: {
+    "opencode-ai": ">=1.0.115",
+    "@otto-assistant/bridge": ">=0.4.90",
+  },
+  pinned: {
+    "opencode-ai": "1.2.20",
+    "@otto-assistant/bridge": "0.4.90",
+  },
+  plugins: [
+    "opencode-agent-memory",
+  ],
+}
+
+/** Upstream repositories for sync tracking */
+export const UPSTREAM_REPOS: Record<string, { repo: string; upstream: string }> = {
+  "@otto-assistant/bridge": {
+    repo: "otto-assistant/bridge",
+    upstream: "remorses/kimaki",
+  },
+}
+
+export const OPENCODE_CONFIG_DIR = (): string => {
+  const home = process.env.HOME || process.env.USERPROFILE || "/root"
+  return `${home}/.config/opencode`
+}
+
+export const KIMAKI_DATA_DIR = (): string => {
+  const home = process.env.HOME || process.env.USERPROFILE || "/root"
+  return `${home}/.kimaki`
+}

package/src/sync.ts

@@ -0,0 +1,53 @@
+import { execSync } from "node:child_process"
+import { UPSTREAM_REPOS } from "./manifest.js"
+
+interface SyncTarget {
+  repo: string
+  upstream: string
+  branch: string
+}
+
+function getSyncTargets(): SyncTarget[] {
+  return Object.entries(UPSTREAM_REPOS).map(([_pkgName, info]) => ({
+    repo: info.repo,
+    upstream: info.upstream,
+    branch: "main",
+  }))
+}
+
+export async function syncUpstreams(): Promise<void> {
+  const targets = getSyncTargets()
+
+  if (targets.length === 0) {
+    console.log("No upstream repos configured for sync.")
+    return
+  }
+
+  // Check gh CLI is available
+  try {
+    execSync("gh --version", { stdio: "pipe" })
+  } catch {
+    console.error("Error: gh CLI is required for sync. Install: https://cli.github.com/")
+    process.exit(1)
+  }
+
+  console.log("Triggering upstream sync for all forked repos:\n")
+
+  for (const target of targets) {
+    console.log(`  ${target.repo} ← ${target.upstream}`)
+    try {
+      execSync(
+        `gh workflow run sync-upstream.yml --repo ${target.repo} --ref ${target.branch}`,
+        { stdio: "pipe" },
+      )
+      console.log(`    ✓ Sync triggered`)
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err)
+      console.error(`    ✗ Failed: ${msg}`)
+    }
+  }
+
+  console.log("\nSync workflows triggered. Check status with: gh run list --repo <repo>")
+}
+
+export { getSyncTargets, UPSTREAM_REPOS }