@otto-assistant/otto 0.1.1 → 0.7.15

package/src/index.ts

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

@@ -1,52 +0,0 @@
-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")
-    // mempalace is a plugin, not a global npm package
-    expect(result).not.toContain("mempalace")
-  })
-
-  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

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

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest"
-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")
-  })
-
-  it("isKimakiRunning returns boolean", () => {
-    const result = isKimakiRunning()
-    expect(typeof result).toBe("boolean")
-  })
-
-  it("restartKimaki is a function", () => {
-    expect(typeof restartKimaki).toBe("function")
-  })
-})

package/src/lifecycle.ts

@@ -1,49 +0,0 @@
-import { execSync } from "node:child_process"
-
-/** 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|bridge'", { encoding: "utf-8", stdio: "pipe" })
-    return output.trim().length > 0
-  } catch {
-    return false
-  }
-}
-
-export function restartKimaki(): void {
-  const bin = detectBinary()
-  if (!bin) {
-    throw new Error(
-      "Neither 'bridge' nor 'kimaki' binary found. Install with: npm install -g @otto-assistant/bridge",
-    )
-  }
-  execSync(`${bin} restart`, {
-    encoding: "utf-8",
-    stdio: "pipe",
-    timeout: 30_000,
-  })
-}

package/src/manifest.ts

@@ -1,42 +0,0 @@
-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.1",
-  packages: {
-    "opencode-ai": ">=1.0.115",
-    "@otto-assistant/bridge": ">=0.6.0",
-  },
-  pinned: {
-    "opencode-ai": "1.2.20",
-    "@otto-assistant/bridge": "0.6.2",
-  },
-  plugins: [
-    "mempalace",
-  ],
-}
-
-/** 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/skills-baseline.ts

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