@otto-assistant/otto 0.1.0 → 0.1.1

package/src/health.test.ts

@@ -1,14 +1,18 @@
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
 import { describe, expect, it } from "vitest"
 import {
   checkPackagePresence,
   checkConfigHealth,
   checkDirectoryHealth,
+  checkTenantHealth,
 } 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)
+    expect(results).toHaveLength(2) // opencode-ai + kimaki (not mempalace — it's a plugin)
     for (const r of results) {
       expect(r).toHaveProperty("name")
       expect(r).toHaveProperty("installed")
@@ -36,4 +40,22 @@ describe("health", () => {
     expect(Array.isArray(results)).toBe(true)
     expect(results.length).toBeGreaterThan(0)
   })
+
+  it("checkTenantHealth reports missing memory bind root as error", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "otto-health-"))
+    const health = checkTenantHealth({ tenantPath: tmpDir })
+    const memoryItem = health.find((h) => h.name === "memory root")
+    expect(memoryItem).toBeDefined()
+    expect(memoryItem!.status).toBe("error")
+  })
+
+  it("checkTenantHealth reports ok when all paths present", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "otto-health-"))
+    fs.mkdirSync(path.join(tmpDir, "memory"))
+    fs.mkdirSync(path.join(tmpDir, "projects"))
+    fs.writeFileSync(path.join(tmpDir, "compose.yml"), "services:", "utf-8")
+    const health = checkTenantHealth({ tenantPath: tmpDir })
+    const errors = health.filter((h) => h.status === "error")
+    expect(errors).toHaveLength(0)
+  })
 })

package/src/health.ts

@@ -69,7 +69,7 @@ export function checkConfigHealth(): ConfigHealth {
 
   const config = state.status === "ok" ? state.config : {}
   const configuredPlugins = config.plugin ?? []
-  const memoryPluginEnabled = configuredPlugins.includes("opencode-agent-memory")
+  const memoryPluginEnabled = configuredPlugins.includes("mempalace")
 
   const subagentPolicyInjected = subagentPolicyInjectedInPrompts(config)
 
@@ -112,3 +112,47 @@ export function checkDirectoryHealth(): HealthResult[] {
   }
   return results
 }
+
+export interface TenantHealthInput {
+  tenantPath: string
+}
+
+export function checkTenantHealth(input: TenantHealthInput): HealthResult[] {
+  const results: HealthResult[] = []
+  const { tenantPath } = input
+
+  if (fs.existsSync(tenantPath)) {
+    results.push({ name: "tenant path", status: "ok", message: `exists: ${tenantPath}` })
+  } else {
+    results.push({ name: "tenant path", status: "error", message: `missing: ${tenantPath}` })
+    return results
+  }
+
+  const composePath = path.join(tenantPath, "compose.yml")
+  if (fs.existsSync(composePath)) {
+    results.push({ name: "compose.yml", status: "ok", message: "present" })
+  } else {
+    results.push({ name: "compose.yml", status: "error", message: "missing — run `otto tenant init`" })
+  }
+
+  const memoryPath = path.join(tenantPath, "memory")
+  if (fs.existsSync(memoryPath)) {
+    try {
+      fs.accessSync(memoryPath, fs.constants.W_OK)
+      results.push({ name: "memory root", status: "ok", message: "writable" })
+    } catch {
+      results.push({ name: "memory root", status: "error", message: "not writable" })
+    }
+  } else {
+    results.push({ name: "memory root", status: "error", message: "missing — run `otto tenant init`" })
+  }
+
+  const projectsPath = path.join(tenantPath, "projects")
+  if (fs.existsSync(projectsPath)) {
+    results.push({ name: "projects mount", status: "ok", message: "present" })
+  } else {
+    results.push({ name: "projects mount", status: "warn", message: "missing — will be created on first up" })
+  }
+
+  return results
+}

package/src/index.ts

@@ -23,6 +23,40 @@ export {
 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"
+export { hasKimakiBinary, isKimakiRunning, restartKimaki, detectBinary } from "./lifecycle.js"
+export { checkPackagePresence, checkConfigHealth, checkDirectoryHealth, checkTenantHealth } from "./health.js"
+export type { HealthResult, PackageCheck, ConfigHealth, TenantHealthInput } from "./health.js"
+export {
+  OPENCODE_SKILLS_DIR,
+  SKILLS_INDEX_PATH,
+  DEFAULT_SKILL_REPOS,
+  parseSkillMd,
+  loadSkillsIndex,
+  saveSkillsIndex,
+  isIndexStale,
+  ensureSkillsIndex,
+  searchSkills,
+  getAllIndexedSkills,
+  fetchRepoSkillsIndex,
+  ghApi,
+  fetchRepoDir,
+  fetchRepoFile,
+  listInstalledSkills,
+  installSkillFromIndex,
+  installSkillsBaseline,
+  removeSkill,
+  getConfiguredRepos,
+} from "./skills.js"
+export type { SkillMeta, SkillIndexEntry, SkillsIndex, RepoSyncResult } from "./skills.js"
+export { GENTLEMAN_SKILLS_BASELINE } from "./skills-baseline.js"
+export type { SkillsBootstrapReport } from "./skills-baseline.js"
+export {
+  deriveComposeProjectName,
+  resolveTenantImage,
+  resolveTenantMode,
+  ensureTenantMemoryLayout,
+  ensureTenantScaffold,
+} from "./tenant.js"
+export type { TenantMode, TenantInitResult } from "./tenant.js"
+export { buildComposeCommand, runCompose } from "./docker.js"
+export type { DockerComposeCommand } from "./docker.js"

package/src/installer.test.ts

@@ -17,8 +17,8 @@ describe("installer", () => {
 
     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")
+    // mempalace is a plugin, not a global npm package
+    expect(result).not.toContain("mempalace")
   })
 
   it("planStableUpgrades returns empty when all packages match pinned", () => {

package/src/lifecycle.test.ts

@@ -1,7 +1,12 @@
 import { describe, expect, it } from "vitest"
-import { hasKimakiBinary, isKimakiRunning, restartKimaki } from "./lifecycle.js"
+import { hasKimakiBinary, isKimakiRunning, restartKimaki, detectBinary } from "./lifecycle.js"
 
 describe("lifecycle", () => {
+  it("detectBinary returns string or null", () => {
+    const result = detectBinary()
+    expect(result === null || typeof result === "string").toBe(true)
+  })
+
   it("hasKimakiBinary returns boolean", () => {
     const result = hasKimakiBinary()
     expect(typeof result).toBe("boolean")
@@ -15,8 +20,4 @@ describe("lifecycle", () => {
   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

@@ -1,17 +1,33 @@
 import { execSync } from "node:child_process"
 
-export function hasKimakiBinary(): boolean {
-  try {
-    execSync("which kimaki", { encoding: "utf-8", stdio: "pipe" })
-    return true
-  } catch {
-    return false
+/** Ordered list of binary names to try — bridge is the otto fork, kimaki is upstream. */
+const BIN_NAMES = ["bridge", "kimaki"] as const
+
+/**
+ * Detect the first available binary name from BIN_NAMES.
+ * Returns the binary name ("bridge" | "kimaki") or null if none found.
+ */
+export function detectBinary(): string | null {
+  for (const name of BIN_NAMES) {
+    try {
+      execSync(`which ${name}`, { encoding: "utf-8", stdio: "pipe" })
+      return name
+    } catch {
+      continue
+    }
   }
+  return null
+}
+
+/** @deprecated Use detectBinary() instead. Returns true if any known binary exists. */
+export function hasKimakiBinary(): boolean {
+  return detectBinary() !== null
 }
 
 export function isKimakiRunning(): boolean {
+  // Check for both process names — "bridge" (otto fork) and "kimaki" (upstream)
   try {
-    const output = execSync("pgrep -f kimaki", { encoding: "utf-8", stdio: "pipe" })
+    const output = execSync("pgrep -f 'kimaki|bridge'", { encoding: "utf-8", stdio: "pipe" })
     return output.trim().length > 0
   } catch {
     return false
@@ -19,10 +35,13 @@ export function isKimakiRunning(): boolean {
 }
 
 export function restartKimaki(): void {
-  if (!hasKimakiBinary()) {
-    throw new Error("kimaki is not installed. Install it first with: npm install -g kimaki")
+  const bin = detectBinary()
+  if (!bin) {
+    throw new Error(
+      "Neither 'bridge' nor 'kimaki' binary found. Install with: npm install -g @otto-assistant/bridge",
+    )
   }
-  execSync("kimaki restart", {
+  execSync(`${bin} restart`, {
     encoding: "utf-8",
     stdio: "pipe",
     timeout: 30_000,

package/src/manifest.ts

@@ -9,17 +9,17 @@ export interface Manifest {
 }
 
 export const MANIFEST: Manifest = {
-  version: "0.1.0",
+  version: "0.1.1",
   packages: {
     "opencode-ai": ">=1.0.115",
-    "@otto-assistant/bridge": ">=0.4.90",
+    "@otto-assistant/bridge": ">=0.6.0",
   },
   pinned: {
     "opencode-ai": "1.2.20",
-    "@otto-assistant/bridge": "0.4.90",
+    "@otto-assistant/bridge": "0.6.2",
   },
   plugins: [
-    "opencode-agent-memory",
+    "mempalace",
   ],
 }
 

package/src/skills-baseline.ts

@@ -0,0 +1,14 @@
+export const GENTLEMAN_SKILLS_BASELINE: string[] = [
+  "critique",
+  "security-review",
+  "simplify",
+  "opensrc",
+  "playwriter",
+  "tuistory",
+]
+
+export interface SkillsBootstrapReport {
+  installed: string[]
+  alreadyPresent: string[]
+  failed: string[]
+}