oh-my-opencode-lite 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1178 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli/install.ts
+import { existsSync as existsSync5 } from "fs";
+
+// src/cli/config-io.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+
+// src/cli/paths.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function getDefaultOpenCodeConfigDir() {
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
+  return join(userConfigDir, "opencode");
+}
+function getCustomOpenCodeConfigDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  return configDir || undefined;
+}
+function getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getDefaultOpenCodeConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+function getConfigJson() {
+  return getOpenCodeConfigPaths()[0];
+}
+function getConfigJsonc() {
+  return getOpenCodeConfigPaths()[1];
+}
+function getLiteConfig() {
+  return join(getConfigDir(), "oh-my-opencode-lite.json");
+}
+function getLiteConfigJsonc() {
+  return join(getConfigDir(), "oh-my-opencode-lite.jsonc");
+}
+function getExistingLiteConfigPath() {
+  const jsonPath = getLiteConfig();
+  if (existsSync(jsonPath))
+    return jsonPath;
+  const jsoncPath = getLiteConfigJsonc();
+  if (existsSync(jsoncPath))
+    return jsoncPath;
+  return jsonPath;
+}
+function getExistingConfigPath() {
+  const jsonPath = getConfigJson();
+  if (existsSync(jsonPath))
+    return jsonPath;
+  const jsoncPath = getConfigJsonc();
+  if (existsSync(jsoncPath))
+    return jsoncPath;
+  return jsonPath;
+}
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+function ensureOpenCodeConfigDir() {
+  const configDir = dirname(getConfigJson());
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+
+// src/cli/providers.ts
+var MODEL_MAPPINGS = {
+  openai: {
+    orchestrator: { model: "openai/gpt-5.4" },
+    oracle: { model: "openai/gpt-5.4", variant: "high" },
+    librarian: { model: "openai/gpt-5.4-mini", variant: "low" },
+    explorer: { model: "openai/gpt-5.4-mini", variant: "low" },
+    designer: { model: "openai/gpt-5.4-mini", variant: "medium" },
+    quick: { model: "openai/gpt-5.4-mini", variant: "low" },
+    deep: { model: "openai/gpt-5.4", variant: "high" }
+  },
+  kimi: {
+    orchestrator: { model: "kimi-for-coding/k2p5" },
+    oracle: { model: "kimi-for-coding/k2p5", variant: "high" },
+    librarian: { model: "kimi-for-coding/k2p5", variant: "low" },
+    explorer: { model: "kimi-for-coding/k2p5", variant: "low" },
+    designer: { model: "kimi-for-coding/k2p5", variant: "medium" },
+    quick: { model: "kimi-for-coding/k2p5", variant: "low" },
+    deep: { model: "kimi-for-coding/k2p5", variant: "high" }
+  },
+  copilot: {
+    orchestrator: { model: "github-copilot/claude-opus-4.6" },
+    oracle: { model: "github-copilot/claude-opus-4.6", variant: "high" },
+    librarian: { model: "github-copilot/grok-code-fast-1", variant: "low" },
+    explorer: { model: "github-copilot/grok-code-fast-1", variant: "low" },
+    designer: {
+      model: "github-copilot/gemini-3.1-pro-preview",
+      variant: "medium"
+    },
+    quick: { model: "github-copilot/claude-sonnet-4.6", variant: "low" },
+    deep: { model: "github-copilot/claude-opus-4.6", variant: "high" }
+  },
+  "zai-plan": {
+    orchestrator: { model: "zai-coding-plan/glm-5" },
+    oracle: { model: "zai-coding-plan/glm-5", variant: "high" },
+    librarian: { model: "zai-coding-plan/glm-5", variant: "low" },
+    explorer: { model: "zai-coding-plan/glm-5", variant: "low" },
+    designer: { model: "zai-coding-plan/glm-5", variant: "medium" },
+    quick: { model: "zai-coding-plan/glm-5", variant: "low" },
+    deep: { model: "zai-coding-plan/glm-5", variant: "high" }
+  }
+};
+function generateLiteConfig(installConfig) {
+  const config = {
+    preset: "openai",
+    presets: {}
+  };
+  const createAgentConfig = (modelInfo) => {
+    return {
+      model: modelInfo.model,
+      variant: modelInfo.variant
+    };
+  };
+  const buildPreset = (mappingName) => {
+    const mapping = MODEL_MAPPINGS[mappingName];
+    return Object.fromEntries(Object.entries(mapping).map(([agentName, modelInfo]) => [
+      agentName,
+      createAgentConfig(modelInfo)
+    ]));
+  };
+  config.presets.openai = buildPreset("openai");
+  if (installConfig.hasTmux) {
+    config.tmux = {
+      enabled: true,
+      layout: "main-vertical",
+      main_pane_size: 60
+    };
+  }
+  return config;
+}
+
+// src/cli/config-io.ts
+var PACKAGE_NAME = "oh-my-opencode-lite";
+function stripJsonComments(json) {
+  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
+  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
+  return json.replace(commentPattern, (match, commentGroup) => commentGroup ? "" : match).replace(trailingCommaPattern, (match, comma, closing) => comma ? closing : match);
+}
+function parseConfigFile(path) {
+  try {
+    if (!existsSync2(path))
+      return { config: null };
+    const stat = statSync(path);
+    if (stat.size === 0)
+      return { config: null };
+    const content = readFileSync(path, "utf-8");
+    if (content.trim().length === 0)
+      return { config: null };
+    return { config: JSON.parse(stripJsonComments(content)) };
+  } catch (err) {
+    return { config: null, error: String(err) };
+  }
+}
+function parseConfig(path) {
+  const result = parseConfigFile(path);
+  if (result.config || result.error)
+    return result;
+  if (path.endsWith(".json")) {
+    const jsoncPath = path.replace(/\.json$/, ".jsonc");
+    return parseConfigFile(jsoncPath);
+  }
+  return { config: null };
+}
+function writeConfig(configPath, config) {
+  if (configPath.endsWith(".jsonc")) {
+    console.warn("[config-manager] Writing to .jsonc file - comments will not be preserved");
+  }
+  const tmpPath = `${configPath}.tmp`;
+  const bakPath = `${configPath}.bak`;
+  const content = `${JSON.stringify(config, null, 2)}
+`;
+  if (existsSync2(configPath)) {
+    copyFileSync(configPath, bakPath);
+  }
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, configPath);
+}
+async function addPluginToOpenCodeConfig() {
+  const configPath = getExistingConfigPath();
+  try {
+    ensureOpenCodeConfigDir();
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to create config directory: ${err}`
+    };
+  }
+  try {
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    const plugins = config.plugin ?? [];
+    const filteredPlugins = plugins.filter((p) => p !== PACKAGE_NAME && !p.startsWith(`${PACKAGE_NAME}@`));
+    filteredPlugins.push(PACKAGE_NAME);
+    config.plugin = filteredPlugins;
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to update opencode config: ${err}`
+    };
+  }
+}
+function writeLiteConfig(installConfig, targetPath) {
+  const configPath = targetPath ?? getLiteConfig();
+  try {
+    ensureConfigDir();
+    const config = generateLiteConfig(installConfig);
+    const tmpPath = `${configPath}.tmp`;
+    const bakPath = `${configPath}.bak`;
+    const content = `${JSON.stringify(config, null, 2)}
+`;
+    if (existsSync2(configPath)) {
+      copyFileSync(configPath, bakPath);
+    }
+    writeFileSync(tmpPath, content);
+    renameSync(tmpPath, configPath);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to write lite config: ${err}`
+    };
+  }
+}
+function disableDefaultAgents() {
+  const configPath = getExistingConfigPath();
+  try {
+    ensureOpenCodeConfigDir();
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    const agent = config.agent ?? {};
+    agent.explore = { disable: true };
+    agent.general = { disable: true };
+    config.agent = agent;
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to disable default agents: ${err}`
+    };
+  }
+}
+function detectCurrentConfig() {
+  const result = {
+    isInstalled: false,
+    hasKimi: false,
+    hasOpenAI: false,
+    hasAnthropic: false,
+    hasCopilot: false,
+    hasZaiPlan: false,
+    hasAntigravity: false,
+    hasChutes: false,
+    hasOpencodeZen: false,
+    hasTmux: false
+  };
+  const { config } = parseConfig(getExistingConfigPath());
+  if (!config)
+    return result;
+  const plugins = config.plugin ?? [];
+  result.isInstalled = plugins.some((p) => p.startsWith(PACKAGE_NAME));
+  result.hasAntigravity = plugins.some((p) => p.startsWith("opencode-antigravity-auth"));
+  const providers = config.provider;
+  result.hasKimi = !!providers?.kimi;
+  result.hasAnthropic = !!providers?.anthropic;
+  result.hasCopilot = !!providers?.["github-copilot"];
+  result.hasZaiPlan = !!providers?.["zai-coding-plan"];
+  result.hasChutes = !!providers?.chutes;
+  if (providers?.google)
+    result.hasAntigravity = true;
+  const { config: liteConfig } = parseConfig(getLiteConfig());
+  if (liteConfig && typeof liteConfig === "object") {
+    const configObj = liteConfig;
+    const presetName = configObj.preset;
+    const presets = configObj.presets;
+    const agents = presets?.[presetName];
+    if (agents) {
+      const models = Object.values(agents).map((a) => a?.model).filter(Boolean);
+      result.hasOpenAI = models.some((m) => m?.startsWith("openai/"));
+      result.hasAnthropic = models.some((m) => m?.startsWith("anthropic/"));
+      result.hasCopilot = models.some((m) => m?.startsWith("github-copilot/"));
+      result.hasZaiPlan = models.some((m) => m?.startsWith("zai-coding-plan/"));
+      result.hasOpencodeZen = models.some((m) => m?.startsWith("opencode/"));
+      if (models.some((m) => m?.startsWith("google/"))) {
+        result.hasAntigravity = true;
+      }
+      if (models.some((m) => m?.startsWith("chutes/"))) {
+        result.hasChutes = true;
+      }
+    }
+    if (configObj.tmux && typeof configObj.tmux === "object") {
+      const tmuxConfig = configObj.tmux;
+      result.hasTmux = tmuxConfig.enabled === true;
+    }
+  }
+  return result;
+}
+// src/cli/system.ts
+import { statSync as statSync2 } from "fs";
+var cachedOpenCodePath = null;
+function getOpenCodePaths() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return [
+    "opencode",
+    `${home}/.local/bin/opencode`,
+    `${home}/.opencode/bin/opencode`,
+    `${home}/bin/opencode`,
+    "/usr/local/bin/opencode",
+    "/opt/opencode/bin/opencode",
+    "/usr/bin/opencode",
+    "/bin/opencode",
+    "/Applications/OpenCode.app/Contents/MacOS/opencode",
+    `${home}/Applications/OpenCode.app/Contents/MacOS/opencode`,
+    "/opt/homebrew/bin/opencode",
+    "/home/linuxbrew/.linuxbrew/bin/opencode",
+    `${home}/homebrew/bin/opencode`,
+    `${home}/Library/Application Support/opencode/bin/opencode`,
+    "/snap/bin/opencode",
+    "/var/snap/opencode/current/bin/opencode",
+    "/var/lib/flatpak/exports/bin/ai.opencode.OpenCode",
+    `${home}/.local/share/flatpak/exports/bin/ai.opencode.OpenCode`,
+    "/nix/store/opencode/bin/opencode",
+    `${home}/.nix-profile/bin/opencode`,
+    "/run/current-system/sw/bin/opencode",
+    `${home}/.cargo/bin/opencode`,
+    `${home}/.npm-global/bin/opencode`,
+    "/usr/local/lib/node_modules/opencode/bin/opencode",
+    `${home}/.yarn/bin/opencode`,
+    `${home}/.pnpm-global/bin/opencode`
+  ];
+}
+function resolveOpenCodePath() {
+  if (cachedOpenCodePath) {
+    return cachedOpenCodePath;
+  }
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    if (opencodePath === "opencode")
+      continue;
+    try {
+      const stat = statSync2(opencodePath);
+      if (stat.isFile()) {
+        cachedOpenCodePath = opencodePath;
+        return opencodePath;
+      }
+    } catch {}
+  }
+  return "opencode";
+}
+async function isOpenCodeInstalled() {
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    try {
+      const proc = Bun.spawn([opencodePath, "--version"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        cachedOpenCodePath = opencodePath;
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
+async function getOpenCodeVersion() {
+  const opencodePath = resolveOpenCodePath();
+  try {
+    const proc = Bun.spawn([opencodePath, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return output.trim();
+    }
+  } catch {}
+  return null;
+}
+function getOpenCodePath() {
+  const path = resolveOpenCodePath();
+  return path === "opencode" ? null : path;
+}
+// src/cli/custom-skills.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  rmSync,
+  statSync as statSync4
+} from "fs";
+import { dirname as dirname2, join as join3, parse } from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/skill-manifest.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync2,
+  statSync as statSync3,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join2, relative } from "path";
+var SHARED_SKILL_DIRECTORY = "_shared";
+var SKILLS_SOURCE_ROOT = join2("src", "skills");
+var MANIFEST_FILE_NAME = ".skill-manifest.json";
+function getManifestPath() {
+  return join2(getCustomSkillsDir(), MANIFEST_FILE_NAME);
+}
+function listFilesRecursive(dirPath) {
+  if (!existsSync3(dirPath)) {
+    return [];
+  }
+  const files = [];
+  const entries = readdirSync(dirPath).sort((left, right) => left.localeCompare(right));
+  for (const entry of entries) {
+    const entryPath = join2(dirPath, entry);
+    const stat = statSync3(entryPath);
+    if (stat.isDirectory()) {
+      files.push(...listFilesRecursive(entryPath));
+      continue;
+    }
+    files.push(entryPath);
+  }
+  return files;
+}
+function readPackageVersion(packageRoot) {
+  const packageJsonPath = join2(packageRoot, "package.json");
+  const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+  if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
+    throw new Error(`Invalid package version in ${packageJsonPath}`);
+  }
+  return packageJson.version;
+}
+function readManifest() {
+  const manifestPath = getManifestPath();
+  if (!existsSync3(manifestPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync2(manifestPath, "utf-8"));
+  } catch (error) {
+    console.warn(`Failed to read skill manifest: ${manifestPath}`, error);
+    return null;
+  }
+}
+function writeManifest(manifest) {
+  const manifestPath = getManifestPath();
+  mkdirSync2(getCustomSkillsDir(), { recursive: true });
+  writeFileSync2(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function computeSkillHash(skillDirPath) {
+  const hash = createHash("sha256");
+  for (const filePath of listFilesRecursive(skillDirPath)) {
+    hash.update(`${relative(skillDirPath, filePath)}
+`);
+    hash.update(readFileSync2(filePath));
+    hash.update(`
+`);
+  }
+  return hash.digest("hex");
+}
+function findRemovedSkills(manifest) {
+  const currentSkillNames = new Set(CUSTOM_SKILLS.map((skill) => skill.name));
+  return Object.keys(manifest.skills).filter((skillName) => !currentSkillNames.has(skillName));
+}
+function checkSkillsNeedUpdate(packageRoot) {
+  const manifest = readManifest();
+  const pluginVersion = readPackageVersion(packageRoot);
+  const sharedHash = computeSkillHash(join2(packageRoot, SKILLS_SOURCE_ROOT, SHARED_SKILL_DIRECTORY));
+  const versionChanged = manifest !== null && manifest.pluginVersion !== pluginVersion;
+  const sharedChanged = manifest !== null && manifest.sharedHash !== sharedHash;
+  const removedSkills = manifest ? findRemovedSkills(manifest) : [];
+  const skillsNeedingUpdate = CUSTOM_SKILLS.flatMap((skill) => {
+    const sourcePath = join2(packageRoot, skill.sourcePath);
+    const targetPath = join2(getCustomSkillsDir(), skill.name);
+    const sourceHash = computeSkillHash(sourcePath);
+    const manifestEntry = manifest?.skills[skill.name];
+    const reasons = [];
+    if (!manifest) {
+      reasons.push("manifest-missing");
+    }
+    if (versionChanged) {
+      reasons.push("version-change");
+    }
+    if (sharedChanged) {
+      reasons.push("shared-hash-mismatch");
+    }
+    if (!manifestEntry) {
+      reasons.push("new-skill");
+    } else if (manifestEntry.hash !== sourceHash) {
+      reasons.push("hash-mismatch");
+    }
+    if (!existsSync3(targetPath)) {
+      reasons.push("missing-install");
+    }
+    if (reasons.length === 0) {
+      return [];
+    }
+    return [
+      {
+        skill,
+        sourceHash,
+        targetPath,
+        reasons
+      }
+    ];
+  });
+  return {
+    pluginVersion,
+    sharedHash,
+    manifest,
+    versionChanged,
+    sharedChanged,
+    needsUpdate: skillsNeedingUpdate.length > 0 || removedSkills.length > 0,
+    skillsNeedingUpdate,
+    removedSkills
+  };
+}
+
+// src/cli/custom-skills.ts
+var SHARED_SKILL_DIRECTORY2 = "_shared";
+var SHARED_SKILL_SOURCE_PATH = `src/skills/${SHARED_SKILL_DIRECTORY2}`;
+var CUSTOM_SKILLS = [
+  {
+    name: "brainstorming",
+    description: "Understand user intent and scope through structured clarification before implementation",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/brainstorming"
+  },
+  {
+    name: "cartography",
+    description: "Repository understanding and hierarchical codemap generation",
+    allowedAgents: ["orchestrator", "explorer"],
+    sourcePath: "src/skills/cartography"
+  },
+  {
+    name: "plan-reviewer",
+    description: "Review SDD task plans for execution blockers and valid references",
+    allowedAgents: ["orchestrator", "oracle"],
+    sourcePath: "src/skills/plan-reviewer"
+  },
+  {
+    name: "sdd-propose",
+    description: "Create change proposals for OpenSpec workflows",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-propose"
+  },
+  {
+    name: "sdd-spec",
+    description: "Write OpenSpec delta specifications",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-spec"
+  },
+  {
+    name: "sdd-design",
+    description: "Create technical design artifacts for changes",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-design"
+  },
+  {
+    name: "sdd-tasks",
+    description: "Generate phased implementation task checklists",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-tasks"
+  },
+  {
+    name: "sdd-apply",
+    description: "Execute tasks and persist implementation progress",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-apply"
+  },
+  {
+    name: "executing-plans",
+    description: "Execute SDD task lists with real-time progress tracking, sub-agent dispatch, and verification checkpoints",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/executing-plans"
+  },
+  {
+    name: "sdd-verify",
+    description: "Build verification reports and compliance matrices",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-verify"
+  },
+  {
+    name: "sdd-archive",
+    description: "Archive completed OpenSpec changes with audit trails",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-archive"
+  }
+];
+function getCustomSkillsDir() {
+  return join3(getConfigDir(), "skills");
+}
+function copyDirRecursive(src, dest) {
+  if (!existsSync4(dest)) {
+    mkdirSync3(dest, { recursive: true });
+  }
+  const entries = readdirSync2(src);
+  for (const entry of entries) {
+    const srcPath = join3(src, entry);
+    const destPath = join3(dest, entry);
+    const stat = statSync4(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      const destDir = dirname2(destPath);
+      if (!existsSync4(destDir)) {
+        mkdirSync3(destDir, { recursive: true });
+      }
+      copyFileSync2(srcPath, destPath);
+    }
+  }
+}
+function installSharedSkillAssets(packageRoot) {
+  const sharedSourcePath = join3(packageRoot, SHARED_SKILL_SOURCE_PATH);
+  const sharedTargetPath = join3(getCustomSkillsDir(), SHARED_SKILL_DIRECTORY2);
+  if (!existsSync4(sharedSourcePath)) {
+    console.error(`Custom skill shared assets not found: ${sharedSourcePath}`);
+    return false;
+  }
+  rmSync(sharedTargetPath, { recursive: true, force: true });
+  copyDirRecursive(sharedSourcePath, sharedTargetPath);
+  return true;
+}
+function findPackageRoot(startDir) {
+  let currentDir = startDir;
+  const filesystemRoot = parse(startDir).root;
+  while (true) {
+    if (existsSync4(join3(currentDir, "package.json")) && existsSync4(join3(currentDir, "src", "skills"))) {
+      return currentDir;
+    }
+    if (currentDir === filesystemRoot) {
+      return null;
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolvePackageRoot(packageRoot) {
+  if (packageRoot) {
+    return packageRoot;
+  }
+  const moduleDir = fileURLToPath(new URL(".", import.meta.url));
+  return findPackageRoot(moduleDir) ?? fileURLToPath(new URL("../..", import.meta.url));
+}
+function installCustomSkillFiles(skill, packageRoot) {
+  const sourcePath = join3(packageRoot, skill.sourcePath);
+  const targetPath = join3(getCustomSkillsDir(), skill.name);
+  if (!existsSync4(sourcePath)) {
+    console.error(`Custom skill source not found: ${sourcePath}`);
+    return false;
+  }
+  rmSync(targetPath, { recursive: true, force: true });
+  copyDirRecursive(sourcePath, targetPath);
+  return true;
+}
+function removeObsoleteSkills(removedSkillNames) {
+  const removedSkills = [];
+  for (const skillName of removedSkillNames) {
+    const targetPath = join3(getCustomSkillsDir(), skillName);
+    try {
+      console.log(`Removing obsolete bundled skill: ${skillName}`);
+      rmSync(targetPath, { recursive: true, force: true });
+      removedSkills.push(skillName);
+    } catch (error) {
+      console.warn(`Failed to remove obsolete bundled skill: ${skillName}`);
+      console.warn(error);
+    }
+  }
+  return removedSkills;
+}
+function buildManifest(packageRoot, updatedSkills, previousManifest, pluginVersion, sharedHash) {
+  const installedAt = new Date().toISOString();
+  const updatedSkillNames = new Set(updatedSkills.map(({ skill }) => skill.name));
+  const skills = Object.fromEntries(CUSTOM_SKILLS.map((skill) => {
+    const previousEntry = previousManifest?.skills[skill.name];
+    const nextInstalledAt = updatedSkillNames.has(skill.name) ? installedAt : previousEntry?.installedAt ?? installedAt;
+    return [
+      skill.name,
+      {
+        hash: computeSkillHash(join3(packageRoot, skill.sourcePath)),
+        installedAt: nextInstalledAt
+      }
+    ];
+  }));
+  return {
+    pluginVersion,
+    sharedHash,
+    skills
+  };
+}
+function pruneRemovedSkillsFromManifest(manifest, removedSkills) {
+  const removedSkillNames = new Set(removedSkills);
+  return {
+    ...manifest,
+    skills: Object.fromEntries(Object.entries(manifest.skills).filter(([skillName]) => !removedSkillNames.has(skillName)))
+  };
+}
+function installCustomSkills(packageRoot = resolvePackageRoot()) {
+  const updateCheck = checkSkillsNeedUpdate(packageRoot);
+  if (!updateCheck.needsUpdate) {
+    return {
+      success: true,
+      updatedSkills: [],
+      skippedSkills: [...CUSTOM_SKILLS],
+      failedSkills: [],
+      removedSkills: []
+    };
+  }
+  const removedSkills = removeObsoleteSkills(updateCheck.removedSkills);
+  if (removedSkills.length > 0 && updateCheck.manifest) {
+    writeManifest(pruneRemovedSkillsFromManifest(updateCheck.manifest, removedSkills));
+  }
+  if (updateCheck.skillsNeedingUpdate.length === 0) {
+    writeManifest(buildManifest(packageRoot, [], updateCheck.manifest, updateCheck.pluginVersion, updateCheck.sharedHash));
+    return {
+      success: true,
+      updatedSkills: [],
+      skippedSkills: [...CUSTOM_SKILLS],
+      failedSkills: [],
+      removedSkills
+    };
+  }
+  if (!installSharedSkillAssets(packageRoot)) {
+    return {
+      success: false,
+      updatedSkills: [],
+      skippedSkills: [],
+      failedSkills: updateCheck.skillsNeedingUpdate.map(({ skill, reasons }) => ({
+        skill,
+        reasons
+      })),
+      removedSkills
+    };
+  }
+  const updatesBySkillName = new Map(updateCheck.skillsNeedingUpdate.map((entry) => [entry.skill.name, entry]));
+  const updatedSkills = [];
+  const skippedSkills = [];
+  const failedSkills = [];
+  for (const skill of CUSTOM_SKILLS) {
+    const pendingUpdate = updatesBySkillName.get(skill.name);
+    if (!pendingUpdate) {
+      skippedSkills.push(skill);
+      continue;
+    }
+    if (installCustomSkillFiles(skill, packageRoot)) {
+      updatedSkills.push({
+        skill,
+        reasons: pendingUpdate.reasons
+      });
+      continue;
+    }
+    failedSkills.push({
+      skill,
+      reasons: pendingUpdate.reasons
+    });
+  }
+  if (failedSkills.length > 0) {
+    return {
+      success: false,
+      updatedSkills,
+      skippedSkills,
+      failedSkills,
+      removedSkills
+    };
+  }
+  writeManifest(buildManifest(packageRoot, updatedSkills, updateCheck.manifest, updateCheck.pluginVersion, updateCheck.sharedHash));
+  return {
+    success: true,
+    updatedSkills,
+    skippedSkills,
+    failedSkills,
+    removedSkills
+  };
+}
+
+// src/cli/skills.ts
+import { spawnSync } from "child_process";
+var RECOMMENDED_SKILLS = [
+  {
+    name: "simplify",
+    repo: "https://github.com/brianlovin/claude-config",
+    skillName: "simplify",
+    description: "YAGNI code simplification expert"
+  },
+  {
+    name: "agent-browser",
+    repo: "https://github.com/vercel-labs/agent-browser",
+    skillName: "agent-browser",
+    description: "High-performance browser automation",
+    postInstallCommands: [
+      "npm install -g agent-browser",
+      "agent-browser install"
+    ]
+  }
+];
+function installSkill(skill) {
+  const args = [
+    "skills",
+    "add",
+    skill.repo,
+    "--skill",
+    skill.skillName,
+    "-a",
+    "opencode",
+    "-y",
+    "--global"
+  ];
+  try {
+    const result = spawnSync("npx", args, { stdio: "inherit" });
+    if (result.status !== 0) {
+      return false;
+    }
+    if (skill.postInstallCommands && skill.postInstallCommands.length > 0) {
+      console.log(`Running post-install commands for ${skill.name}...`);
+      for (const cmd of skill.postInstallCommands) {
+        console.log(`> ${cmd}`);
+        const [command, ...cmdArgs] = cmd.split(" ");
+        const cmdResult = spawnSync(command, cmdArgs, { stdio: "inherit" });
+        if (cmdResult.status !== 0) {
+          console.warn(`Post-install command failed: ${cmd}`);
+        }
+      }
+    }
+    return true;
+  } catch (error) {
+    console.error(`Failed to install skill: ${skill.name}`, error);
+    return false;
+  }
+}
+
+// src/cli/install.ts
+var GREEN = "\x1B[32m";
+var BLUE = "\x1B[34m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var SYMBOLS = {
+  check: `${GREEN}\u2713${RESET}`,
+  cross: `${RED}\u2717${RESET}`,
+  arrow: `${BLUE}\u2192${RESET}`,
+  bullet: `${DIM}\u2022${RESET}`,
+  info: `${BLUE}\u2139${RESET}`,
+  warn: `${YELLOW}\u26A0${RESET}`,
+  star: `${YELLOW}\u2605${RESET}`
+};
+function printHeader(isUpdate) {
+  console.log();
+  console.log(`${BOLD}oh-my-opencode-lite ${isUpdate ? "Update" : "Install"}${RESET}`);
+  console.log("=".repeat(30));
+  console.log();
+}
+function printStep(step, total, message) {
+  console.log(`${DIM}[${step}/${total}]${RESET} ${message}`);
+}
+function printSuccess(message) {
+  console.log(`${SYMBOLS.check} ${message}`);
+}
+function printError(message) {
+  console.log(`${SYMBOLS.cross} ${RED}${message}${RESET}`);
+}
+function printInfo(message) {
+  console.log(`${SYMBOLS.info} ${message}`);
+}
+function formatCustomSkillReasons(report) {
+  if (report.updatedSkills.length === 0 && report.removedSkills.length === 0) {
+    return "all bundled skills already up to date";
+  }
+  return `${report.updatedSkills.length} updated, ${report.removedSkills.length} removed, ${report.skippedSkills.length} unchanged`;
+}
+function formatSkillReasons(reasons) {
+  return reasons.join(", ");
+}
+async function checkOpenCodeInstalled() {
+  const installed = await isOpenCodeInstalled();
+  if (!installed) {
+    printError("OpenCode is not installed on this system.");
+    printInfo("Install it with:");
+    console.log(`     ${BLUE}curl -fsSL https://opencode.ai/install | bash${RESET}`);
+    console.log();
+    printInfo("Or if already installed, add it to your PATH:");
+    console.log(`     ${BLUE}export PATH="$HOME/.local/bin:$PATH"${RESET}`);
+    console.log(`     ${BLUE}export PATH="$HOME/.opencode/bin:$PATH"${RESET}`);
+    return { ok: false };
+  }
+  const version = await getOpenCodeVersion();
+  const path = getOpenCodePath();
+  const detectedVersion = version ?? "";
+  const pathInfo = path ? ` (${DIM}${path}${RESET})` : "";
+  printSuccess(`OpenCode ${detectedVersion} detected${pathInfo}`);
+  return { ok: true, version: version ?? undefined, path: path ?? undefined };
+}
+function handleStepResult(result, successMsg) {
+  if (!result.success) {
+    printError(`Failed: ${result.error}`);
+    return false;
+  }
+  printSuccess(`${successMsg} ${SYMBOLS.arrow} ${DIM}${result.configPath}${RESET}`);
+  return true;
+}
+function formatConfigSummary() {
+  const lines = [];
+  lines.push(`${BOLD}Configuration Summary${RESET}`);
+  lines.push("");
+  lines.push(`  ${BOLD}Preset:${RESET} ${BLUE}openai${RESET}`);
+  lines.push(`  ${SYMBOLS.check} Seven-agent oh-my-opencode-lite roster`);
+  lines.push(`  ${SYMBOLS.check} OpenAI models by default`);
+  lines.push(`  ${SYMBOLS.check} thoth-mem enabled for orchestrator memory`);
+  lines.push(`  ${SYMBOLS.check} Delegation results persisted to disk`);
+  lines.push(`  ${SYMBOLS.check} Bundled SDD skills ready for install`);
+  const seeDocs = "see docs/provider-configurations.md";
+  lines.push(`  ${DIM}\u25CB Kimi \u2014 ${seeDocs}${RESET}`);
+  lines.push(`  ${DIM}\u25CB GitHub Copilot \u2014 ${seeDocs}${RESET}`);
+  lines.push(`  ${DIM}\u25CB ZAI Coding Plan \u2014 ${seeDocs}${RESET}`);
+  return lines.join(`
+`);
+}
+async function runInstall(config) {
+  const detected = detectCurrentConfig();
+  const isUpdate = detected.isInstalled;
+  printHeader(isUpdate);
+  let totalSteps = 4;
+  if (config.installSkills)
+    totalSteps += 1;
+  if (config.installCustomSkills)
+    totalSteps += 1;
+  let step = 1;
+  printStep(step++, totalSteps, "Checking OpenCode installation...");
+  if (config.dryRun) {
+    printInfo("Dry run mode - skipping OpenCode check");
+  } else {
+    const { ok } = await checkOpenCodeInstalled();
+    if (!ok)
+      return 1;
+  }
+  printStep(step++, totalSteps, "Adding oh-my-opencode-lite plugin...");
+  if (config.dryRun) {
+    printInfo("Dry run mode - skipping plugin installation");
+  } else {
+    const pluginResult = await addPluginToOpenCodeConfig();
+    if (!handleStepResult(pluginResult, "Plugin added"))
+      return 1;
+  }
+  printStep(step++, totalSteps, "Disabling OpenCode default agents...");
+  if (config.dryRun) {
+    printInfo("Dry run mode - skipping agent disabling");
+  } else {
+    const agentResult = disableDefaultAgents();
+    if (!handleStepResult(agentResult, "Default agents disabled"))
+      return 1;
+  }
+  printStep(step++, totalSteps, "Writing oh-my-opencode-lite configuration...");
+  if (config.dryRun) {
+    const liteConfig = generateLiteConfig(config);
+    printInfo("Dry run mode - configuration that would be written:");
+    console.log(`
+${JSON.stringify(liteConfig, null, 2)}
+`);
+  } else {
+    const configPath = getExistingLiteConfigPath();
+    const configExists = existsSync5(configPath);
+    if (configExists && !config.reset) {
+      printInfo(`Configuration already exists at ${configPath}. ` + "Use --reset to overwrite.");
+    } else {
+      const liteResult = writeLiteConfig(config, configExists ? configPath : undefined);
+      if (!handleStepResult(liteResult, configExists ? "Config reset" : "Config written"))
+        return 1;
+    }
+  }
+  if (config.installSkills) {
+    printStep(step++, totalSteps, "Installing recommended external skills...");
+    if (config.dryRun) {
+      printInfo("Dry run mode - would install skills:");
+      for (const skill of RECOMMENDED_SKILLS) {
+        printInfo(`  - ${skill.name}`);
+      }
+    } else {
+      let skillsInstalled = 0;
+      for (const skill of RECOMMENDED_SKILLS) {
+        printInfo(`Installing ${skill.name}...`);
+        if (installSkill(skill)) {
+          printSuccess(`Installed: ${skill.name}`);
+          skillsInstalled++;
+        } else {
+          printInfo(`Skipped: ${skill.name} (already installed)`);
+        }
+      }
+      printSuccess(`${skillsInstalled}/${RECOMMENDED_SKILLS.length} skills processed`);
+    }
+  }
+  if (config.installCustomSkills) {
+    printStep(step++, totalSteps, "Installing bundled oh-my-opencode-lite skills...");
+    if (config.dryRun) {
+      printInfo("Dry run mode - would install bundled skills:");
+      for (const skill of CUSTOM_SKILLS) {
+        printInfo(`  - ${skill.name}`);
+      }
+    } else {
+      const report = installCustomSkills();
+      for (const updatedSkill of report.updatedSkills) {
+        printSuccess(`Installed: ${updatedSkill.skill.name} (${formatSkillReasons(updatedSkill.reasons)})`);
+      }
+      for (const skippedSkill of report.skippedSkills) {
+        printInfo(`Up to date: ${skippedSkill.name}`);
+      }
+      for (const removedSkill of report.removedSkills) {
+        printInfo(`Removed obsolete skill: ${removedSkill}`);
+      }
+      for (const failedSkill of report.failedSkills) {
+        printError(`Failed: ${failedSkill.skill.name} (${formatSkillReasons(failedSkill.reasons)})`);
+      }
+      if (!report.success) {
+        return 1;
+      }
+      printSuccess(`Bundled skills processed: ${formatCustomSkillReasons(report)}`);
+    }
+  }
+  console.log();
+  console.log(formatConfigSummary());
+  console.log();
+  const statusMsg = isUpdate ? "oh-my-opencode-lite updated!" : "oh-my-opencode-lite installation complete!";
+  console.log(`${SYMBOLS.star} ${BOLD}${GREEN}${statusMsg}${RESET}`);
+  console.log();
+  console.log(`${BOLD}Next steps:${RESET}`);
+  console.log();
+  console.log(`  1. Start OpenCode:`);
+  console.log(`     ${BLUE}$ opencode${RESET}`);
+  console.log();
+  const modelsInfo = "Default configuration uses OpenAI models (gpt-5.4 / gpt-5.4-mini).";
+  console.log(`${BOLD}${modelsInfo}${RESET}`);
+  console.log(`  ${DIM}Includes the seven-agent roster, thoth-mem memory defaults,${RESET}`);
+  console.log(`  ${DIM}delegation persistence, and bundled SDD skills.${RESET}`);
+  const altProviders = "For alternative providers (Kimi, GitHub Copilot, ZAI Coding Plan)";
+  console.log(`${BOLD}${altProviders}, see:${RESET}`);
+  const docsUrl = "https://github.com/EremesNG/oh-my-opencode-lite/" + "blob/master/docs/provider-configurations.md";
+  console.log(`  ${BLUE}${docsUrl}${RESET}`);
+  console.log();
+  return 0;
+}
+function createInstallConfig(args) {
+  return {
+    hasTmux: args.tmux === "yes",
+    installSkills: args.skills === "yes",
+    installCustomSkills: true,
+    dryRun: args.dryRun,
+    reset: args.reset ?? false
+  };
+}
+async function install(args) {
+  return runInstall(createInstallConfig(args));
+}
+
+// src/cli/index.ts
+function parseArgs(args) {
+  const result = {
+    tui: true
+  };
+  for (const arg of args) {
+    if (arg === "--no-tui") {
+      result.tui = false;
+    } else if (arg.startsWith("--tmux=")) {
+      result.tmux = arg.split("=")[1];
+    } else if (arg.startsWith("--skills=")) {
+      result.skills = arg.split("=")[1];
+    } else if (arg === "--dry-run") {
+      result.dryRun = true;
+    } else if (arg === "--reset") {
+      result.reset = true;
+    } else if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return result;
+}
+function printHelp() {
+  console.log(`
+oh-my-opencode-lite installer (oh-my-opencode-lite)
+
+Usage: bunx oh-my-opencode-lite install [OPTIONS]
+
+Options:
+  --tmux=yes|no          Enable tmux integration (yes/no)
+  --skills=yes|no        Install recommended external skills
+  --no-tui               Non-interactive mode
+  --dry-run              Simulate install without writing files
+  --reset                Force overwrite of existing configuration
+  -h, --help             Show this help message
+
+oh-my-opencode-lite installs the seven-agent roster, thoth-mem defaults,
+delegation persistence, and bundled SDD skills for OpenCode.
+
+Bundled oh-my-opencode-lite skills are always installed.
+Use --skills=no to skip only recommended external skills.
+
+The generated config uses OpenAI by default.
+For alternative providers, see docs/provider-configurations.md.
+
+Examples:
+  bunx oh-my-opencode-lite@latest install
+  bunx oh-my-opencode-lite install --no-tui --tmux=no --skills=yes
+  bunx oh-my-opencode-lite install --dry-run
+  bunx oh-my-opencode-lite install --reset
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "install") {
+    const hasSubcommand = args[0] === "install";
+    const installArgs = parseArgs(args.slice(hasSubcommand ? 1 : 0));
+    const exitCode = await install(installArgs);
+    process.exit(exitCode);
+  } else if (args[0] === "-h" || args[0] === "--help") {
+    printHelp();
+    process.exit(0);
+  } else {
+    console.error(`Unknown command: ${args[0]}`);
+    console.error("Run with --help for usage information");
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});