@cockpit-ai/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1444 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { mkdirSync, existsSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { createInterface } from "readline";
+import { COCKPIT_DIR, CONFIG_FILE } from "@cockpit-ai/core";
+
+// src/ui/output.ts
+import chalk from "chalk";
+var ui = {
+  success: (msg) => console.log(chalk.green("\u2713") + " " + msg),
+  error: (msg) => console.error(chalk.red("\u2717") + " " + msg),
+  warn: (msg) => console.warn(chalk.yellow("!") + " " + msg),
+  info: (msg) => console.log(chalk.blue("\u2192") + " " + msg),
+  dim: (msg) => console.log(chalk.dim(msg)),
+  heading: (msg) => console.log("\n" + chalk.bold(msg)),
+  blank: () => console.log()
+};
+function formatKey(key) {
+  return chalk.cyan(key);
+}
+function formatValue(value) {
+  if (value == null || value === "") return chalk.dim("(none)");
+  return chalk.white(value);
+}
+function formatList(items) {
+  if (items.length === 0) return chalk.dim("(empty)");
+  return items.map((i) => chalk.white(i)).join(", ");
+}
+function printKeyValue(key, value) {
+  console.log(`  ${formatKey(key.padEnd(20))} ${formatValue(value)}`);
+}
+function printKeyList(key, items) {
+  console.log(`  ${formatKey(key.padEnd(20))} ${formatList(items)}`);
+}
+
+// src/commands/init.ts
+async function prompt(question, defaultValue) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const display = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+  return new Promise((resolve9) => {
+    rl.question(display, (answer) => {
+      rl.close();
+      resolve9(answer.trim() || defaultValue || "");
+    });
+  });
+}
+function workspaceTemplate(name) {
+  return `cockpit: "1.0"
+
+workspace:
+  name: ${name}
+  default_adapter: claude-code
+
+adapters:
+  - claude-code
+
+context:
+  global:
+    - "Follow project coding conventions"
+`;
+}
+function projectTemplate(name) {
+  return `cockpit: "1.0"
+
+project:
+  name: ${name}
+
+context:
+  global: []
+`;
+}
+async function initCommand(targetPath, options) {
+  const dir = resolve(targetPath ?? process.cwd());
+  const cockpitDir = join(dir, COCKPIT_DIR);
+  const configPath = join(cockpitDir, CONFIG_FILE);
+  if (existsSync(configPath)) {
+    ui.warn(`Cockpit config already exists at ${configPath}`);
+    ui.info("Use 'cockpit status' to view the current configuration.");
+    return;
+  }
+  const isProject = options.project === true;
+  const kind = isProject ? "project" : "workspace";
+  ui.heading(`Initializing Cockpit ${kind}`);
+  ui.info(`Target directory: ${dir}`);
+  ui.blank();
+  const defaultName = dir.split("/").at(-1) ?? "my-workspace";
+  const name = await prompt(`${kind} name`, defaultName);
+  mkdirSync(cockpitDir, { recursive: true });
+  const content = isProject ? projectTemplate(name) : workspaceTemplate(name);
+  writeFileSync(configPath, content, "utf-8");
+  ui.blank();
+  ui.success(`Created ${configPath}`);
+  ui.blank();
+  ui.dim("Next steps:");
+  ui.dim(`  cockpit status         \u2014 view current environment`);
+  ui.dim(`  cockpit skill list     \u2014 browse available skills`);
+  ui.dim(`  cockpit apply          \u2014 apply config to AI tools`);
+}
+
+// src/commands/status.ts
+import { resolve as resolve2 } from "path";
+import chalk2 from "chalk";
+import {
+  findConfigPaths,
+  resolveConfig
+} from "@cockpit-ai/core";
+async function statusCommand(targetPath) {
+  const cwd = resolve2(targetPath ?? process.cwd());
+  const paths = findConfigPaths(cwd);
+  if (!paths.workspacePath && !paths.projectPath) {
+    ui.warn("No Cockpit configuration found.");
+    ui.dim(`Searched from: ${cwd}`);
+    ui.blank();
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    return;
+  }
+  const config = resolveConfig(paths);
+  ui.heading("Cockpit Status");
+  console.log(chalk2.bold("  Workspace"));
+  printKeyValue("Name", config.name);
+  printKeyValue("Default Adapter", config.defaultAdapter);
+  printKeyList("Adapters", config.adapters);
+  ui.blank();
+  console.log(chalk2.bold("  Config Paths"));
+  printKeyValue("Profile", config.profilePath);
+  printKeyValue("Workspace", config.workspacePath);
+  printKeyValue("Project", config.projectPath);
+  ui.blank();
+  console.log(chalk2.bold("  Preferences"));
+  printKeyValue("Language", config.preferences.language);
+  printKeyValue("Default Model", config.preferences.defaultModel);
+  ui.blank();
+  if (config.context.global.length > 0) {
+    console.log(chalk2.bold("  Context Rules"));
+    for (const rule of config.context.global) {
+      console.log(`    ${chalk2.dim("\u2022")} ${rule}`);
+    }
+    ui.blank();
+  }
+  if (config.skills.include.length > 0 || config.agents.include.length > 0) {
+    console.log(chalk2.bold("  Resources"));
+    if (config.skills.include.length > 0) {
+      printKeyList("Skill paths", config.skills.include);
+    }
+    if (config.agents.include.length > 0) {
+      printKeyList("Agent paths", config.agents.include);
+    }
+    ui.blank();
+  }
+}
+
+// src/commands/apply.ts
+import { resolve as resolve3, join as join2 } from "path";
+import ora from "ora";
+import {
+  findConfigPaths as findConfigPaths2,
+  resolveConfig as resolveConfig2,
+  buildResolvedContext,
+  COCKPIT_DIR as COCKPIT_DIR2
+} from "@cockpit-ai/core";
+import { getAdapters } from "@cockpit-ai/adapters";
+import { SkillRegistry } from "@cockpit-ai/skills";
+async function applyCommand(options) {
+  const cwd = resolve3(process.cwd());
+  const paths = findConfigPaths2(cwd);
+  if (!paths.workspacePath && !paths.projectPath) {
+    ui.error("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    process.exit(1);
+  }
+  const config = resolveConfig2(paths);
+  const targetAdapterNames = options.adapter ? [options.adapter] : config.adapters;
+  const adapters = getAdapters(targetAdapterNames);
+  if (adapters.length === 0) {
+    ui.warn("No supported adapters found.");
+    ui.dim(`Requested: ${targetAdapterNames.join(", ")}`);
+    return;
+  }
+  ui.heading("Cockpit Apply");
+  ui.info(`Workspace: ${config.name}`);
+  ui.blank();
+  const skillDirs = config.skills.include.map((p) => {
+    if (p.startsWith(".")) {
+      const root = paths.workspacePath ? resolve3(join2(paths.workspacePath, "..", "..")) : cwd;
+      return resolve3(join2(root, p));
+    }
+    return resolve3(p);
+  });
+  const workspaceRoot = paths.workspacePath ? resolve3(join2(paths.workspacePath, "..", "..")) : null;
+  const projectRoot = paths.projectPath ? resolve3(join2(paths.projectPath, "..", "..")) : null;
+  const defaultDirs = [
+    workspaceRoot ? join2(workspaceRoot, COCKPIT_DIR2, "skills") : null,
+    projectRoot ? join2(projectRoot, COCKPIT_DIR2, "skills") : null
+  ].filter(Boolean);
+  const allSkillDirs = [.../* @__PURE__ */ new Set([...defaultDirs, ...skillDirs])];
+  const registry = new SkillRegistry();
+  const loadErrors = registry.loadFromDirs(allSkillDirs);
+  for (const { file, error } of loadErrors) {
+    ui.warn(`Skipped skill ${file}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const skills = registry.list();
+  const context = buildResolvedContext(
+    config.context.global,
+    config.context.project,
+    "cockpit"
+  );
+  for (const adapter of adapters) {
+    const spinner = ora(`Applying to ${adapter.name}\u2026`).start();
+    try {
+      if (options.clean) {
+        await adapter.clean(cwd);
+        spinner.info(`Cleaned ${adapter.name}`);
+        continue;
+      }
+      if (context.global.length > 0 || context.project.length > 0) {
+        await adapter.applyContext(cwd, context);
+      }
+      for (const skill of skills) {
+        await adapter.applySkill(cwd, skill);
+      }
+      const parts = [];
+      if (context.global.length + context.project.length > 0) {
+        parts.push(`${context.global.length + context.project.length} context rules`);
+      }
+      if (skills.length > 0) {
+        parts.push(`${skills.length} skill${skills.length === 1 ? "" : "s"}`);
+      }
+      spinner.succeed(
+        `${adapter.name}: ${parts.length > 0 ? parts.join(", ") : "nothing to apply"}`
+      );
+    } catch (err) {
+      spinner.fail(`${adapter.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  ui.blank();
+}
+
+// src/commands/skill.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, cpSync, rmSync } from "fs";
+import { join as join3, resolve as resolve4, basename, extname } from "path";
+import { findConfigPaths as findConfigPaths3, COCKPIT_DIR as COCKPIT_DIR3 } from "@cockpit-ai/core";
+import { SkillRegistry as SkillRegistry2, defaultSkillTemplate } from "@cockpit-ai/skills";
+import chalk3 from "chalk";
+var SKILLS_SUBDIR = "skills";
+function getSkillsDir(cockpitRoot) {
+  return join3(cockpitRoot, COCKPIT_DIR3, SKILLS_SUBDIR);
+}
+function findCockpitRoot(cwd) {
+  const paths = findConfigPaths3(cwd);
+  if (paths.projectPath) return resolve4(join3(paths.projectPath, "..", ".."));
+  if (paths.workspacePath) return resolve4(join3(paths.workspacePath, "..", ".."));
+  return null;
+}
+function collectAllSkillDirs(cwd) {
+  const paths = findConfigPaths3(cwd);
+  const dirs = [];
+  if (paths.workspacePath) {
+    dirs.push(getSkillsDir(resolve4(join3(paths.workspacePath, "..", ".."))));
+  }
+  if (paths.projectPath) {
+    dirs.push(getSkillsDir(resolve4(join3(paths.projectPath, "..", ".."))));
+  }
+  return dirs;
+}
+async function skillListCommand() {
+  const cwd = process.cwd();
+  const skillDirs = collectAllSkillDirs(cwd);
+  if (skillDirs.length === 0) {
+    ui.warn("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    return;
+  }
+  const registry = new SkillRegistry2();
+  const errors = registry.loadFromDirs(skillDirs);
+  for (const { file, error } of errors) {
+    ui.warn(`Skipped ${file}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const skills = registry.list();
+  if (skills.length === 0) {
+    ui.info("No skills found.");
+    ui.dim("Use 'cockpit skill create <name>' to scaffold a new skill.");
+    return;
+  }
+  ui.heading(`Skills (${skills.length})`);
+  for (const skill of skills) {
+    const triggers = skill.trigger.length > 0 ? chalk3.dim(` [${skill.trigger.join(", ")}]`) : "";
+    console.log(`  ${chalk3.cyan(skill.name)}@${chalk3.dim(skill.version)}${triggers}`);
+    if (skill.description) {
+      console.log(`    ${chalk3.dim(skill.description)}`);
+    }
+  }
+  ui.blank();
+}
+async function skillCreateCommand(name) {
+  const cwd = process.cwd();
+  const cockpitRoot = findCockpitRoot(cwd);
+  if (!cockpitRoot) {
+    ui.error("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    process.exit(1);
+  }
+  const skillsDir = getSkillsDir(cockpitRoot);
+  mkdirSync2(skillsDir, { recursive: true });
+  const fileName = `${name}.yaml`;
+  const filePath = join3(skillsDir, fileName);
+  if (existsSync2(filePath)) {
+    ui.warn(`Skill '${name}' already exists at ${filePath}`);
+    return;
+  }
+  const content = defaultSkillTemplate(name);
+  writeFileSync2(filePath, content, "utf-8");
+  ui.success(`Created skill: ${filePath}`);
+  ui.dim(`Edit the file, then run 'cockpit apply' to apply it to your AI tools.`);
+}
+async function skillAddCommand(source) {
+  const cwd = process.cwd();
+  const cockpitRoot = findCockpitRoot(cwd);
+  if (!cockpitRoot) {
+    ui.error("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    process.exit(1);
+  }
+  const sourcePath = resolve4(source);
+  if (!existsSync2(sourcePath)) {
+    ui.error(`File not found: ${sourcePath}`);
+    process.exit(1);
+  }
+  const ext = extname(sourcePath);
+  if (ext !== ".yaml" && ext !== ".yml") {
+    ui.error("Only .yaml or .yml skill files are supported.");
+    process.exit(1);
+  }
+  const skillsDir = getSkillsDir(cockpitRoot);
+  mkdirSync2(skillsDir, { recursive: true });
+  const destPath = join3(skillsDir, basename(sourcePath));
+  cpSync(sourcePath, destPath);
+  ui.success(`Added skill from ${sourcePath}`);
+  ui.dim(`Run 'cockpit skill list' to see all skills.`);
+}
+async function skillRemoveCommand(name) {
+  const cwd = process.cwd();
+  const cockpitRoot = findCockpitRoot(cwd);
+  if (!cockpitRoot) {
+    ui.error("No Cockpit configuration found.");
+    process.exit(1);
+  }
+  const skillsDir = getSkillsDir(cockpitRoot);
+  const candidates = [`${name}.yaml`, `${name}.yml`];
+  let removed = false;
+  for (const fileName of candidates) {
+    const filePath = join3(skillsDir, fileName);
+    if (existsSync2(filePath)) {
+      rmSync(filePath);
+      ui.success(`Removed skill '${name}'`);
+      removed = true;
+      break;
+    }
+  }
+  if (!removed) {
+    ui.error(`Skill '${name}' not found in ${skillsDir}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/profile.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync } from "fs";
+import { resolve as resolve5 } from "path";
+import { createInterface as createInterface2 } from "readline";
+import { execSync } from "child_process";
+import { stringify as yamlStringify } from "yaml";
+import {
+  ProfileConfigSchema,
+  WorkspaceConfigSchema,
+  getProfilePath,
+  getProfileDir,
+  tryLoadConfig,
+  findConfigPaths as findConfigPaths4,
+  resolveConfig as resolveConfig3
+} from "@cockpit-ai/core";
+async function prompt2(question, defaultValue) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const display = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+  return new Promise((resolve9) => {
+    rl.question(display, (answer) => {
+      rl.close();
+      resolve9(answer.trim() || defaultValue || "");
+    });
+  });
+}
+function profileTemplate(opts) {
+  return `cockpit: "1.0"
+
+profile:
+  name: ${opts.name}
+  sync:
+    remote: ""
+    auto_sync: false
+
+preferences:
+  language: ${opts.language}
+  default_model: ${opts.defaultModel}
+  default_adapter: ${opts.defaultAdapter}
+
+context:
+  global: []
+`;
+}
+function runGit(args, cwd) {
+  return execSync(`git ${args}`, { cwd, stdio: "pipe" }).toString().trim();
+}
+function isGitRepo(dir) {
+  try {
+    runGit("rev-parse --is-inside-work-tree", dir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasCommits(dir) {
+  try {
+    runGit("rev-parse HEAD", dir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasRemote(dir) {
+  try {
+    const remotes = runGit("remote", dir);
+    return remotes.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function profileShowCommand() {
+  const profilePath = getProfilePath();
+  const profileDir = getProfileDir();
+  ui.heading("Cockpit Profile");
+  printKeyValue("Profile dir", profileDir);
+  printKeyValue("Profile file", profilePath);
+  ui.blank();
+  if (!existsSync3(profilePath)) {
+    ui.warn("No profile found.");
+    ui.info("Run 'cockpit profile create' to set up your profile.");
+    return;
+  }
+  const profile = tryLoadConfig(profilePath, ProfileConfigSchema);
+  if (!profile) {
+    ui.error(`Failed to load profile from ${profilePath}`);
+    ui.info("The file may be corrupted. Run 'cockpit profile create' to recreate it.");
+    return;
+  }
+  if (profile.profile) {
+    printKeyValue("Name", profile.profile.name);
+    if (profile.profile.sync) {
+      const sync = profile.profile.sync;
+      printKeyValue("Sync remote", sync.remote ?? "(none)");
+      printKeyValue("Auto sync", sync.auto_sync ? "yes" : "no");
+    }
+    ui.blank();
+  }
+  if (profile.preferences) {
+    ui.dim("Preferences");
+    printKeyValue("Language", profile.preferences.language);
+    printKeyValue("Default model", profile.preferences.default_model);
+    printKeyValue("Default adapter", profile.preferences.default_adapter);
+    ui.blank();
+  }
+  if (profile.context?.global && profile.context.global.length > 0) {
+    ui.dim("Global context rules");
+    for (const rule of profile.context.global) {
+      console.log(`    \u2022 ${rule}`);
+    }
+    ui.blank();
+  }
+  const profileDirResolved = resolve5(profileDir);
+  if (existsSync3(profileDirResolved)) {
+    ui.dim("Sync status");
+    if (isGitRepo(profileDirResolved)) {
+      printKeyValue("Git repo", "yes");
+      try {
+        const branch = runGit("rev-parse --abbrev-ref HEAD", profileDirResolved);
+        printKeyValue("Branch", branch);
+        if (hasRemote(profileDirResolved)) {
+          const remote = runGit("remote get-url origin", profileDirResolved);
+          printKeyValue("Remote origin", remote);
+        } else {
+          printKeyValue("Remote origin", "(none)");
+        }
+      } catch {
+      }
+    } else {
+      printKeyValue("Git repo", "no");
+      ui.dim("  Run 'cockpit profile sync push' to initialize git sync.");
+    }
+    ui.blank();
+  }
+}
+async function profileCreateCommand() {
+  const profilePath = getProfilePath();
+  const profileDir = getProfileDir();
+  ui.heading("Create Cockpit Profile");
+  ui.info(`Profile will be saved to: ${profilePath}`);
+  ui.blank();
+  if (existsSync3(profilePath)) {
+    const existing = tryLoadConfig(profilePath, ProfileConfigSchema);
+    const existingName = existing?.profile?.name;
+    ui.warn(`A profile already exists${existingName ? ` for '${existingName}'` : ""}.`);
+    const overwrite = await prompt2("Overwrite? [y/N]", "N");
+    if (overwrite.toLowerCase() !== "y") {
+      ui.info("Aborted. Existing profile unchanged.");
+      return;
+    }
+    ui.blank();
+  }
+  const name = await prompt2("Your name", process.env["USER"] ?? "");
+  const language = await prompt2("Preferred language code (e.g. en, ko, ja)", "en");
+  const defaultModel = await prompt2("Default AI model", "claude-sonnet-4-6");
+  const defaultAdapter = await prompt2(
+    "Default adapter (claude-code, cursor, copilot, opencode)",
+    "claude-code"
+  );
+  const validAdapters = ["claude-code", "cursor", "copilot", "opencode"];
+  if (!validAdapters.includes(defaultAdapter)) {
+    ui.error(`Invalid adapter '${defaultAdapter}'. Must be one of: ${validAdapters.join(", ")}`);
+    process.exit(1);
+  }
+  mkdirSync3(profileDir, { recursive: true });
+  const content = profileTemplate({ name, language, defaultModel, defaultAdapter });
+  writeFileSync3(profilePath, content, "utf-8");
+  ui.blank();
+  ui.success(`Profile created at ${profilePath}`);
+  ui.blank();
+  ui.dim("Next steps:");
+  ui.dim("  cockpit profile show         \u2014 view your profile");
+  ui.dim("  cockpit profile sync push    \u2014 sync profile to a remote git repo");
+  ui.dim("  cockpit status               \u2014 view merged environment config");
+}
+async function profileSyncPushCommand() {
+  const profilePath = getProfilePath();
+  const profileDir = resolve5(getProfileDir());
+  if (!existsSync3(profilePath)) {
+    ui.error("No profile found.");
+    ui.info("Run 'cockpit profile create' first.");
+    process.exit(1);
+  }
+  const profile = tryLoadConfig(profilePath, ProfileConfigSchema);
+  const remote = profile?.profile?.sync?.remote;
+  ui.heading("Profile Sync \u2014 Push");
+  mkdirSync3(profileDir, { recursive: true });
+  if (!isGitRepo(profileDir)) {
+    ui.info("Initializing git repository in profile directory...");
+    try {
+      runGit("init", profileDir);
+      ui.success("Git repository initialized.");
+    } catch (err) {
+      ui.error(`Failed to initialize git repo: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  }
+  if (remote && remote.trim() !== "") {
+    try {
+      const existingRemotes = runGit("remote", profileDir);
+      if (!existingRemotes.split("\n").includes("origin")) {
+        runGit(`remote add origin ${remote}`, profileDir);
+        ui.success(`Remote 'origin' set to: ${remote}`);
+      }
+    } catch (err) {
+      ui.warn(`Could not configure remote: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  try {
+    runGit("add .", profileDir);
+  } catch (err) {
+    ui.error(`Failed to stage files: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  let hasChanges = false;
+  try {
+    const status = runGit("status --porcelain", profileDir);
+    hasChanges = status.trim().length > 0;
+  } catch {
+    hasChanges = true;
+  }
+  if (hasChanges || !hasCommits(profileDir)) {
+    try {
+      runGit(`commit -m "sync"`, profileDir);
+      ui.success("Committed profile changes.");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes("nothing to commit")) {
+        ui.error(`Failed to commit: ${msg}`);
+        process.exit(1);
+      } else {
+        ui.info("Nothing new to commit.");
+      }
+    }
+  } else {
+    ui.info("Nothing new to commit.");
+  }
+  if (remote && remote.trim() !== "") {
+    ui.info(`Pushing to remote: ${remote}`);
+    try {
+      let branch = "main";
+      try {
+        branch = runGit("rev-parse --abbrev-ref HEAD", profileDir);
+      } catch {
+      }
+      runGit(`push -u origin ${branch}`, profileDir);
+      ui.success("Profile pushed to remote.");
+    } catch (err) {
+      ui.error(`Push failed: ${err instanceof Error ? err.message : String(err)}`);
+      ui.dim("Ensure the remote is accessible and you have push permissions.");
+      process.exit(1);
+    }
+  } else {
+    ui.warn("No remote configured in profile.sync.remote \u2014 skipping push.");
+    ui.dim("Edit your profile and add a 'sync.remote' URL, then run this command again.");
+  }
+  ui.blank();
+}
+async function profileSyncPullCommand() {
+  const profilePath = getProfilePath();
+  const profileDir = resolve5(getProfileDir());
+  ui.heading("Profile Sync \u2014 Pull");
+  const profile = tryLoadConfig(profilePath, ProfileConfigSchema);
+  const remote = profile?.profile?.sync?.remote;
+  if (!existsSync3(profileDir) || !isGitRepo(profileDir)) {
+    if (remote && remote.trim() !== "") {
+      ui.info(`Cloning profile from remote: ${remote}`);
+      try {
+        const parentDir = resolve5(profileDir, "..");
+        const dirName = profileDir.split("/").at(-1) ?? ".cockpit";
+        mkdirSync3(parentDir, { recursive: true });
+        execSync(`git clone ${remote} ${dirName}`, { cwd: parentDir, stdio: "pipe" });
+        ui.success("Profile cloned from remote.");
+      } catch (err) {
+        ui.error(`Clone failed: ${err instanceof Error ? err.message : String(err)}`);
+        ui.dim(`Remote: ${remote}`);
+        process.exit(1);
+      }
+    } else {
+      ui.error("Profile directory is not a git repository and no remote is configured.");
+      ui.info("Run 'cockpit profile create' and configure 'sync.remote' first.");
+      process.exit(1);
+    }
+  } else {
+    if (!hasRemote(profileDir)) {
+      ui.error("No git remote configured in the profile directory.");
+      if (remote && remote.trim() !== "") {
+        ui.info("Adding remote from profile config...");
+        try {
+          runGit(`remote add origin ${remote}`, profileDir);
+          ui.success(`Remote 'origin' set to: ${remote}`);
+        } catch (err) {
+          ui.error(`Failed to add remote: ${err instanceof Error ? err.message : String(err)}`);
+          process.exit(1);
+        }
+      } else {
+        ui.dim("Set 'sync.remote' in your profile.yaml and try again.");
+        process.exit(1);
+      }
+    }
+    ui.info("Pulling latest changes from remote...");
+    try {
+      runGit("pull", profileDir);
+      ui.success("Profile updated from remote.");
+    } catch (err) {
+      ui.error(`Pull failed: ${err instanceof Error ? err.message : String(err)}`);
+      ui.dim("Check your network connection and remote access permissions.");
+      process.exit(1);
+    }
+  }
+  ui.blank();
+  ui.dim("Run 'cockpit profile show' to view the updated profile.");
+  ui.blank();
+}
+async function profileExportCommand(outputFile) {
+  const profilePath = getProfilePath();
+  const cwd = process.cwd();
+  const outPath = resolve5(outputFile ?? "cockpit-profile-export.yaml");
+  ui.heading("Profile Export");
+  if (!existsSync3(profilePath)) {
+    ui.error("No profile found.");
+    ui.info("Run 'cockpit profile create' first.");
+    process.exit(1);
+  }
+  const profile = tryLoadConfig(profilePath, ProfileConfigSchema);
+  if (!profile) {
+    ui.error(`Failed to load profile from ${profilePath}`);
+    process.exit(1);
+  }
+  const paths = findConfigPaths4(cwd);
+  paths.profilePath = profilePath;
+  let workspaceConfig = null;
+  if (paths.workspacePath) {
+    workspaceConfig = tryLoadConfig(paths.workspacePath, WorkspaceConfigSchema);
+  }
+  const resolved = resolveConfig3(paths);
+  const exportedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const exportDoc = {
+    cockpit: "1.0",
+    exported_at: exportedAt
+  };
+  if (profile.profile) {
+    exportDoc["profile"] = profile.profile;
+  }
+  exportDoc["preferences"] = {
+    language: resolved.preferences.language,
+    default_model: resolved.preferences.defaultModel,
+    default_adapter: resolved.defaultAdapter
+  };
+  if (resolved.context.global.length > 0 || resolved.context.project.length > 0) {
+    const contextExport = {};
+    if (resolved.context.global.length > 0) {
+      contextExport["global"] = resolved.context.global;
+    }
+    if (resolved.context.project.length > 0) {
+      contextExport["project"] = resolved.context.project;
+    }
+    exportDoc["context"] = contextExport;
+  }
+  if (workspaceConfig?.workspace) {
+    exportDoc["workspace"] = workspaceConfig.workspace;
+  }
+  if (resolved.adapters.length > 0) {
+    exportDoc["adapters"] = resolved.adapters;
+  }
+  const header = `# Cockpit Profile Export \u2014 generated by cockpit profile export
+`;
+  const body = yamlStringify(exportDoc, { lineWidth: 0 });
+  writeFileSync3(outPath, header + body, "utf-8");
+  ui.blank();
+  ui.success(`Exported to: ${outPath}`);
+  ui.blank();
+  ui.dim(`Profile: ${profilePath}`);
+  if (paths.workspacePath) {
+    ui.dim(`Workspace: ${paths.workspacePath}`);
+  }
+  ui.dim(`Exported at: ${exportedAt}`);
+  ui.blank();
+}
+async function profileImportCommand(inputFile) {
+  const inputPath = resolve5(inputFile);
+  const profilePath = getProfilePath();
+  const profileDir = getProfileDir();
+  ui.heading("Profile Import");
+  ui.info(`Importing from: ${inputPath}`);
+  ui.blank();
+  if (!existsSync3(inputPath)) {
+    ui.error(`Import file not found: ${inputPath}`);
+    process.exit(1);
+  }
+  let rawContent = "";
+  try {
+    rawContent = readFileSync(inputPath, "utf-8");
+  } catch (err) {
+    ui.error(`Failed to read file: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  let parsed = null;
+  try {
+    const { parse: parseYaml } = await import("yaml");
+    parsed = parseYaml(rawContent);
+  } catch (err) {
+    ui.error(`Invalid YAML in import file: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    ui.error("Import file does not contain a valid Cockpit export document.");
+    process.exit(1);
+  }
+  const doc = parsed;
+  if (doc["cockpit"] === void 0) {
+    ui.warn("Import file does not have a 'cockpit' version field. Proceeding with caution.");
+  }
+  if (existsSync3(profilePath)) {
+    const existing = tryLoadConfig(profilePath, ProfileConfigSchema);
+    const existingName = existing?.profile?.name;
+    ui.warn(`An existing profile${existingName ? ` for '${existingName}'` : ""} will be overwritten.`);
+    const overwrite = await prompt2("Continue? [y/N]", "N");
+    if (overwrite.toLowerCase() !== "y") {
+      ui.info("Aborted. Existing profile unchanged.");
+      return;
+    }
+    ui.blank();
+  }
+  const profileDoc = {
+    cockpit: doc["cockpit"] ?? "1.0"
+  };
+  if (doc["profile"] !== void 0) {
+    profileDoc["profile"] = doc["profile"];
+  }
+  if (doc["preferences"] !== void 0) {
+    profileDoc["preferences"] = doc["preferences"];
+  }
+  if (doc["context"] !== void 0) {
+    profileDoc["context"] = doc["context"];
+  }
+  const profileResult = ProfileConfigSchema.safeParse(profileDoc);
+  if (!profileResult.success) {
+    ui.error("Import file does not contain a valid profile configuration:");
+    for (const issue of profileResult.error.issues) {
+      ui.dim(`  ${issue.path.join(".")}: ${issue.message}`);
+    }
+    process.exit(1);
+  }
+  mkdirSync3(profileDir, { recursive: true });
+  const profileYaml = yamlStringify(profileDoc, { lineWidth: 0 });
+  writeFileSync3(profilePath, profileYaml, "utf-8");
+  ui.success(`Profile imported to: ${profilePath}`);
+  if (doc["workspace"] !== void 0 && doc["adapters"] !== void 0) {
+    ui.blank();
+    ui.info("The export file also contains workspace configuration.");
+    ui.dim("Workspace settings were NOT imported (they belong in .cockpit/config.yaml).");
+    ui.dim("Run 'cockpit init' in your workspace to create a workspace config.");
+  }
+  ui.blank();
+  ui.dim("Run 'cockpit profile show' to verify the imported profile.");
+  ui.blank();
+}
+
+// src/commands/agent.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4, resolve as resolve6 } from "path";
+import { AgentRegistry, setAgentStatus, getAgentStatus, readAgentState } from "@cockpit-ai/agents";
+import { findConfigPaths as findConfigPaths5, COCKPIT_DIR as COCKPIT_DIR4 } from "@cockpit-ai/core";
+import chalk4 from "chalk";
+function collectAgentDirs(cwd) {
+  const paths = findConfigPaths5(cwd);
+  const dirs = [];
+  if (paths.workspacePath) {
+    dirs.push(join4(resolve6(join4(paths.workspacePath, "..", "..")), COCKPIT_DIR4, "agents"));
+  }
+  if (paths.projectPath) {
+    dirs.push(join4(resolve6(join4(paths.projectPath, "..", "..")), COCKPIT_DIR4, "agents"));
+  }
+  return dirs;
+}
+function statusColor(status) {
+  switch (status) {
+    case "running":
+      return chalk4.green(status);
+    case "stopped":
+      return chalk4.dim(status);
+    case "error":
+      return chalk4.red(status);
+    default:
+      return chalk4.cyan(status);
+  }
+}
+async function agentListCommand() {
+  const cwd = process.cwd();
+  const agentDirs = collectAgentDirs(cwd);
+  if (agentDirs.length === 0) {
+    ui.warn("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    return;
+  }
+  const registry = new AgentRegistry();
+  const errors = registry.loadFromDirs(agentDirs);
+  for (const { file, error } of errors) {
+    ui.warn(`Skipped ${file}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const agents = registry.list();
+  if (agents.length === 0) {
+    ui.info("No agents found.");
+    ui.dim("Add agent YAML files to a .cockpit/agents/ directory.");
+    return;
+  }
+  ui.heading(`Agents (${agents.length})`);
+  for (const agent of agents) {
+    const currentStatus = getAgentStatus(agent.name);
+    console.log(
+      `  ${chalk4.cyan(agent.name)} ${chalk4.dim("\xB7")} ${statusColor(currentStatus)}`
+    );
+    console.log(`    ${chalk4.dim("role:")}  ${agent.role}`);
+    console.log(`    ${chalk4.dim("model:")} ${agent.model}`);
+    if (agent.skills.length > 0) {
+      console.log(`    ${chalk4.dim("skills:")} ${agent.skills.join(", ")}`);
+    }
+  }
+  ui.blank();
+}
+async function agentSpawnCommand(name) {
+  const cwd = process.cwd();
+  const agentDirs = collectAgentDirs(cwd);
+  if (agentDirs.length === 0) {
+    ui.error("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    process.exit(1);
+  }
+  const registry = new AgentRegistry();
+  registry.loadFromDirs(agentDirs);
+  const agent = registry.get(name);
+  if (!agent) {
+    ui.error(`Agent '${name}' not found.`);
+    ui.dim(`Run 'cockpit agent list' to see available agents.`);
+    process.exit(1);
+  }
+  setAgentStatus(name, "running");
+  const claudeDir = join4(cwd, ".claude");
+  if (existsSync4(claudeDir)) {
+    const agentsDir = join4(claudeDir, "agents");
+    mkdirSync4(agentsDir, { recursive: true });
+    const contextLines = [
+      `# Agent: ${agent.name}`,
+      ``,
+      `**Role:** ${agent.role}`,
+      `**Model:** ${agent.model}`
+    ];
+    if (agent.skills.length > 0) {
+      contextLines.push(``, `## Skills`, ``);
+      for (const skill of agent.skills) {
+        contextLines.push(`- ${skill}`);
+      }
+    }
+    if (agent.contextRules.length > 0) {
+      contextLines.push(``, `## Context Rules`, ``);
+      for (const rule of agent.contextRules) {
+        contextLines.push(`- ${rule}`);
+      }
+    }
+    if (agent.contextIncludes.length > 0) {
+      contextLines.push(``, `## Context Includes`, ``);
+      for (const include of agent.contextIncludes) {
+        contextLines.push(`- ${include}`);
+      }
+    }
+    const contextPath = join4(agentsDir, `${name}.md`);
+    writeFileSync4(contextPath, contextLines.join("\n") + "\n", "utf-8");
+    ui.dim(`Wrote context to ${contextPath}`);
+  }
+  ui.success(`Agent '${name}' spawned.`);
+  ui.dim(`Run 'cockpit agent stop ${name}' to mark it as stopped.`);
+}
+async function agentStopCommand(name) {
+  setAgentStatus(name, "stopped");
+  ui.success(`Agent '${name}' stopped.`);
+}
+async function agentStatusCommand() {
+  const state = readAgentState();
+  const entries = Object.entries(state.agents);
+  if (entries.length === 0) {
+    ui.info("No agent state recorded.");
+    ui.dim("Spawn an agent with 'cockpit agent spawn <name>'.");
+    return;
+  }
+  ui.heading("Agent Status Dashboard");
+  for (const [agentName, entry] of entries) {
+    console.log(`  ${chalk4.cyan(agentName)}`);
+    console.log(`    ${chalk4.dim("status:")}    ${statusColor(entry.status)}`);
+    if (entry.startedAt) {
+      console.log(`    ${chalk4.dim("started:")}   ${entry.startedAt}`);
+    }
+    if (entry.stoppedAt) {
+      console.log(`    ${chalk4.dim("stopped:")}   ${entry.stoppedAt}`);
+    }
+    if (entry.pid != null) {
+      console.log(`    ${chalk4.dim("pid:")}       ${entry.pid}`);
+    }
+    ui.blank();
+  }
+}
+
+// src/commands/worktree.ts
+import {
+  WorktreeManager,
+  registerWorktree,
+  unregisterWorktree,
+  assignAgent,
+  readWorktreeState,
+  getWorktreeState
+} from "@cockpit-ai/worktree";
+import chalk5 from "chalk";
+import { resolve as resolve7 } from "path";
+import { existsSync as existsSync5 } from "fs";
+async function worktreeCreateCommand(branch, options) {
+  const repoPath = resolve7(options.repo ?? process.cwd());
+  const manager = new WorktreeManager(repoPath);
+  try {
+    const info = manager.create({
+      branch,
+      path: options.path ? resolve7(options.path) : void 0
+    });
+    registerWorktree(info.path, info.branch);
+    ui.success(`Created worktree for branch ${chalk5.cyan(info.branch)}`);
+    ui.info(`Path: ${info.path}`);
+  } catch (err) {
+    ui.error(`Failed to create worktree: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+async function worktreeListCommand() {
+  const repoPath = resolve7(process.cwd());
+  const manager = new WorktreeManager(repoPath);
+  let gitWorktrees = [];
+  try {
+    gitWorktrees = manager.list();
+  } catch (err) {
+    ui.warn(`Could not list git worktrees: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const state = readWorktreeState();
+  if (gitWorktrees.length === 0 && Object.keys(state.worktrees).length === 0) {
+    ui.info("No worktrees found.");
+    return;
+  }
+  ui.heading("Worktrees");
+  const allPaths = /* @__PURE__ */ new Set([
+    ...gitWorktrees.map((wt) => wt.path),
+    ...Object.keys(state.worktrees)
+  ]);
+  console.log(
+    `  ${chalk5.bold("Path".padEnd(40))} ${chalk5.bold("Branch".padEnd(25))} ${chalk5.bold("Agent")}`
+  );
+  console.log(`  ${chalk5.dim("\u2500".repeat(80))}`);
+  for (const path of allPaths) {
+    const gitEntry = gitWorktrees.find((wt) => wt.path === path);
+    const stateEntry = state.worktrees[path];
+    const branch = gitEntry?.branch ?? stateEntry?.branch ?? chalk5.dim("(unknown)");
+    const agent = stateEntry?.assignedAgent ?? chalk5.dim("(none)");
+    const mainTag = gitEntry?.isMain ? chalk5.dim(" [main]") : "";
+    const truncatedPath = path.length > 39 ? "..." + path.slice(path.length - 36) : path;
+    console.log(
+      `  ${chalk5.cyan(truncatedPath.padEnd(40))} ${chalk5.white(branch.padEnd(25))}${mainTag} ${chalk5.yellow(agent)}`
+    );
+  }
+  ui.blank();
+}
+async function worktreeStatusCommand() {
+  const state = readWorktreeState();
+  const entries = Object.values(state.worktrees);
+  if (entries.length === 0) {
+    ui.info("No tracked worktrees in Cockpit state.");
+    ui.dim("Use 'cockpit worktree create <branch>' to create one.");
+    return;
+  }
+  ui.heading(`Worktree Status (${entries.length})`);
+  for (const entry of entries) {
+    const exists = existsSync5(entry.path);
+    const statusMark = exists ? chalk5.green("active") : chalk5.red("missing");
+    console.log(`  ${chalk5.cyan(entry.branch)} ${chalk5.dim("\u2014")} ${statusMark}`);
+    console.log(`    ${chalk5.dim("Path:")}       ${entry.path}`);
+    console.log(`    ${chalk5.dim("Agent:")}      ${entry.assignedAgent ?? chalk5.dim("(none)")}`);
+    console.log(`    ${chalk5.dim("Created:")}    ${entry.createdAt}`);
+    ui.blank();
+  }
+}
+async function worktreeAssignCommand(worktreePath, agentName) {
+  const resolvedPath = resolve7(worktreePath);
+  const existing = getWorktreeState(resolvedPath);
+  if (!existing) {
+    ui.error(`Worktree not found in state: ${resolvedPath}`);
+    ui.dim("Use 'cockpit worktree list' to see tracked worktrees.");
+    process.exit(1);
+  }
+  try {
+    assignAgent(resolvedPath, agentName);
+    ui.success(
+      `Assigned agent ${chalk5.yellow(agentName)} to worktree ${chalk5.cyan(existing.branch)}`
+    );
+  } catch (err) {
+    ui.error(`Failed to assign agent: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+async function worktreeCleanCommand() {
+  const repoPath = resolve7(process.cwd());
+  const manager = new WorktreeManager(repoPath);
+  try {
+    manager.prune();
+    ui.info("Pruned stale git worktree references.");
+  } catch (err) {
+    ui.warn(
+      `git worktree prune failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const state = readWorktreeState();
+  const staleEntries = Object.values(state.worktrees).filter(
+    (entry) => !existsSync5(entry.path)
+  );
+  if (staleEntries.length === 0) {
+    ui.info("No stale worktree entries to clean.");
+    return;
+  }
+  for (const entry of staleEntries) {
+    unregisterWorktree(entry.path);
+    ui.success(`Removed stale entry: ${chalk5.cyan(entry.branch)} (${entry.path})`);
+  }
+  ui.blank();
+  ui.dim(`Cleaned ${staleEntries.length} stale entry${staleEntries.length === 1 ? "" : "ies"}.`);
+}
+
+// src/commands/context.ts
+import { existsSync as existsSync6, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
+import { join as join5, resolve as resolve8 } from "path";
+import { ContextManager, contextSummary, buildClaudeMdSection } from "@cockpit-ai/context";
+import {
+  findConfigPaths as findConfigPaths6,
+  resolveConfig as resolveConfig4,
+  buildResolvedContext as buildResolvedContext2
+} from "@cockpit-ai/core";
+import chalk6 from "chalk";
+var COCKPIT_MARKER = "<!-- cockpit:managed -->";
+var CLAUDE_MD = "CLAUDE.md";
+async function contextShowCommand() {
+  const cwd = resolve8(process.cwd());
+  const paths = findConfigPaths6(cwd);
+  if (!paths.workspacePath && !paths.projectPath) {
+    ui.error("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    process.exit(1);
+  }
+  const config = resolveConfig4(paths);
+  const manager = new ContextManager(cwd);
+  const context = manager.getResolved();
+  ui.heading("Context");
+  ui.blank();
+  console.log(chalk6.bold("Config Sources"));
+  if (config.profilePath) {
+    console.log(`  ${chalk6.cyan("profile".padEnd(12))} ${chalk6.dim(config.profilePath)}`);
+  }
+  if (config.workspacePath) {
+    console.log(`  ${chalk6.cyan("workspace".padEnd(12))} ${chalk6.dim(config.workspacePath)}`);
+  }
+  if (config.projectPath) {
+    console.log(`  ${chalk6.cyan("project".padEnd(12))} ${chalk6.dim(config.projectPath)}`);
+  }
+  ui.blank();
+  console.log(chalk6.bold("Global Rules"));
+  if (context.global.length === 0) {
+    console.log(`  ${chalk6.dim("(none)")}`);
+  } else {
+    for (const rule of context.global) {
+      const source = rule.source ? chalk6.dim(` [${rule.source}]`) : "";
+      console.log(`  ${chalk6.white("-")} ${rule.content}${source}`);
+    }
+  }
+  ui.blank();
+  console.log(chalk6.bold("Project Rules"));
+  if (context.project.length === 0) {
+    console.log(`  ${chalk6.dim("(none)")}`);
+  } else {
+    for (const rule of context.project) {
+      const source = rule.source ? chalk6.dim(` [${rule.source}]`) : "";
+      console.log(`  ${chalk6.white("-")} ${rule.content}${source}`);
+    }
+  }
+  ui.blank();
+  const summary = contextSummary(context);
+  console.log(chalk6.bold("Summary"));
+  console.log(`  ${chalk6.cyan("total".padEnd(12))} ${summary.totalRules}`);
+  console.log(`  ${chalk6.cyan("global".padEnd(12))} ${summary.globalCount}`);
+  console.log(`  ${chalk6.cyan("project".padEnd(12))} ${summary.projectCount}`);
+  ui.blank();
+}
+async function contextAddCommand(rule, options) {
+  const cwd = resolve8(process.cwd());
+  const paths = findConfigPaths6(cwd);
+  if (!paths.workspacePath && !paths.projectPath) {
+    ui.error("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    process.exit(1);
+  }
+  const scope = options.project || options.scope === "project" ? "project" : "global";
+  const manager = new ContextManager(cwd);
+  try {
+    manager.addRule(rule, scope);
+  } catch (err) {
+    ui.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const targetPath = paths.projectPath ?? paths.workspacePath;
+  ui.success(`Added ${scope} rule`);
+  ui.dim(`  Rule:  ${rule}`);
+  ui.dim(`  Scope: ${scope}`);
+  ui.dim(`  File:  ${targetPath}`);
+  ui.blank();
+  ui.info("Run 'cockpit context generate' to apply the context to your AI tools.");
+}
+async function contextGenerateCommand() {
+  const cwd = resolve8(process.cwd());
+  const paths = findConfigPaths6(cwd);
+  if (!paths.workspacePath && !paths.projectPath) {
+    ui.error("No Cockpit configuration found.");
+    ui.info("Run 'cockpit init' to initialize a workspace.");
+    process.exit(1);
+  }
+  const config = resolveConfig4(paths);
+  const context = buildResolvedContext2(
+    config.context.global,
+    config.context.project,
+    "cockpit"
+  );
+  const claudeMdPath = join5(cwd, CLAUDE_MD);
+  const claudeSection = buildClaudeMdSection(context);
+  const existing = existsSync6(claudeMdPath) ? readFileSync2(claudeMdPath, "utf-8") : null;
+  let finalContent;
+  if (!existing) {
+    finalContent = claudeSection;
+  } else {
+    const markerIndex = existing.indexOf(COCKPIT_MARKER);
+    const base = markerIndex >= 0 ? existing.slice(0, markerIndex).trimEnd() : existing.trimEnd();
+    finalContent = base ? `${base}
+
+${claudeSection}` : claudeSection;
+  }
+  writeFileSync5(claudeMdPath, finalContent, "utf-8");
+  ui.heading("Context Generate");
+  ui.blank();
+  const totalRules = context.global.length + context.project.length;
+  if (totalRules === 0) {
+    ui.warn("No context rules defined. Wrote empty cockpit section.");
+  } else {
+    ui.success(`Wrote ${totalRules} context rule${totalRules === 1 ? "" : "s"} to ${CLAUDE_MD}`);
+    ui.dim(`  Global:  ${context.global.length}`);
+    ui.dim(`  Project: ${context.project.length}`);
+  }
+  ui.dim(`  Path: ${claudeMdPath}`);
+  ui.blank();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("cockpit").description("AI-first Development Environment Orchestrator").version("0.0.1");
+program.command("init [path]").description("Initialize a Cockpit workspace or project").option("--project", "Initialize as a project config (instead of workspace)").action(async (path, opts) => {
+  try {
+    await initCommand(path, { project: opts.project });
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("status [path]").description("Show current Cockpit environment status").action(async (path) => {
+  try {
+    await statusCommand(path);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("apply").description("Apply Cockpit config to AI tools in the current project").option("--adapter <name>", "Apply only to a specific adapter").option("--clean", "Remove cockpit-managed files instead of applying").action(async (opts) => {
+  try {
+    await applyCommand({
+      adapter: opts.adapter,
+      clean: opts.clean
+    });
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var skillCmd = program.command("skill").description("Manage Cockpit skills");
+skillCmd.command("list").description("List all available skills").action(async () => {
+  try {
+    await skillListCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+skillCmd.command("create <name>").description("Scaffold a new skill from template").action(async (name) => {
+  try {
+    await skillCreateCommand(name);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+skillCmd.command("add <path>").description("Add a skill from a local file").action(async (path) => {
+  try {
+    await skillAddCommand(path);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+skillCmd.command("remove <name>").description("Remove a skill").action(async (name) => {
+  try {
+    await skillRemoveCommand(name);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var profileCmd = program.command("profile").description("Manage your personal Cockpit profile");
+profileCmd.command("show").description("Display current profile info").action(async () => {
+  try {
+    await profileShowCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+profileCmd.command("create").description("Create a new profile interactively").action(async () => {
+  try {
+    await profileCreateCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var syncCmd = profileCmd.command("sync").description("Sync profile with remote git repository");
+syncCmd.command("push").description("Push profile to remote").action(async () => {
+  try {
+    await profileSyncPushCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+syncCmd.command("pull").description("Pull profile from remote").action(async () => {
+  try {
+    await profileSyncPullCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+profileCmd.command("export [file]").description("Export profile to a single YAML file").action(async (file) => {
+  try {
+    await profileExportCommand(file);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+profileCmd.command("import <file>").description("Import profile from a YAML export file").action(async (file) => {
+  try {
+    await profileImportCommand(file);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var agentCmd = program.command("agent").description("Manage Cockpit agents");
+agentCmd.command("list").description("List available agents").action(async () => {
+  try {
+    await agentListCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+agentCmd.command("spawn <name>").description("Spawn an agent").action(async (name) => {
+  try {
+    await agentSpawnCommand(name);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+agentCmd.command("stop <name>").description("Stop a running agent").action(async (name) => {
+  try {
+    await agentStopCommand(name);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+agentCmd.command("status").description("Show agent status dashboard").action(async () => {
+  try {
+    await agentStatusCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var worktreeCmd = program.command("worktree").description("Manage git worktrees");
+worktreeCmd.command("create <branch>").description("Create a new worktree").option("--repo <path>", "Path to git repo (default: cwd)").option("--path <path>", "Where to create the worktree").action(async (branch, opts) => {
+  try {
+    await worktreeCreateCommand(branch, { repo: opts.repo, path: opts.path });
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+worktreeCmd.command("list").description("List all worktrees").action(async () => {
+  try {
+    await worktreeListCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+worktreeCmd.command("status").description("Show worktree status dashboard").action(async () => {
+  try {
+    await worktreeStatusCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+worktreeCmd.command("assign <worktree> <agent>").description("Assign an agent to a worktree").action(async (wt, agent) => {
+  try {
+    await worktreeAssignCommand(wt, agent);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+worktreeCmd.command("clean").description("Clean up stale worktrees").action(async () => {
+  try {
+    await worktreeCleanCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var contextCmd = program.command("context").description("Manage context rules");
+contextCmd.command("show").description("Show current merged context").action(async () => {
+  try {
+    await contextShowCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+contextCmd.command("add <rule>").description("Add a context rule").option("--project", "Add as a project-scoped rule (default: global)").option("--scope <scope>", "Rule scope: global or project").action(async (rule, opts) => {
+  try {
+    await contextAddCommand(rule, {
+      scope: opts.scope,
+      project: opts.project
+    });
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+contextCmd.command("generate").description("Generate adapter context files (CLAUDE.md etc.)").action(async () => {
+  try {
+    await contextGenerateCommand();
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map