konstruct 0.1.0

package/dist/index.js

@@ -0,0 +1,1197 @@
+import {
+  AGENT_REGISTRY,
+  Banner,
+  KONSTRUCT_DIR,
+  MultiSelect,
+  StatusMessage,
+  addSkillToManifest,
+  diffHashes,
+  exists,
+  getAgentLabels,
+  getAgentSkillDirs,
+  hashDirectory,
+  initCommand,
+  parseSkillEntry,
+  parseSource,
+  readConfig,
+  readManifest,
+  removeSkillFromManifest,
+  writeConfig
+} from "./chunk-MYTZHNE6.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { readFileSync } from "fs";
+import pc from "picocolors";
+
+// src/cli/commands/add.tsx
+import { render, Box as Box2, useApp } from "ink";
+import { useState as useState3, useCallback, useEffect as useEffect2 } from "react";
+
+// src/core/installer.ts
+import { mkdir, rm as rm2, cp } from "fs/promises";
+import { resolve, join as join3, relative } from "path";
+
+// src/core/git.ts
+import simpleGit from "simple-git";
+import { join } from "path";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+var CLONE_TIMEOUT_MS = 6e4;
+var GitCloneError = class extends Error {
+  constructor(message, url, isTimeout = false, isAuthError = false) {
+    super(message);
+    this.name = "GitCloneError";
+    this.url = url;
+    this.isTimeout = isTimeout;
+    this.isAuthError = isAuthError;
+  }
+  /** Infer auth transport from the URL. */
+  getAuthType() {
+    return this.url.startsWith("git@") || this.url.startsWith("ssh://") ? "ssh" : "https";
+  }
+};
+function httpsToSshUrl(url) {
+  const match = url.match(/^https:\/\/(github\.com|gitlab\.com)\/(.+)$/);
+  if (!match) return null;
+  return `git@${match[1]}:${match[2]}`;
+}
+function formatAuthTroubleshootingGuide(url, transport) {
+  const displayUrl = url.replace(/^(https?:\/\/|git@|ssh:\/\/)/, "").replace(/\.git$/, "").replace(":", "/");
+  let guide = `Authentication failed for ${displayUrl}.
+
+  Troubleshooting steps:
+
+`;
+  guide += `    1. Verify the repository exists and you have access.
+
+`;
+  if (transport === "https" || transport === "both") {
+    guide += `    ${transport === "both" ? "2" : "2"}. HTTPS \u2014 check your credential state:
+`;
+    guide += `         gh auth status
+`;
+    guide += `         gh auth login
+
+`;
+  }
+  if (transport === "ssh" || transport === "both") {
+    const num = transport === "both" ? "3" : "2";
+    guide += `    ${num}. SSH \u2014 check your key state:
+`;
+    guide += `         ssh-add -l                     # list loaded keys
+`;
+    guide += `         ssh -T git@github.com          # test the connection
+
+`;
+  }
+  if (transport === "both") {
+    guide += `    4. If using corporate SSO, make sure your SSH key or
+`;
+    guide += `       token has been authorized for your organization.
+`;
+  }
+  return guide.trimEnd();
+}
+async function cloneRepo(url, ref, options) {
+  const useSsh = options?.ssh ?? false;
+  if (useSsh) {
+    const sshUrl = httpsToSshUrl(url) ?? url;
+    return attemptClone(sshUrl, ref, url, "ssh");
+  }
+  try {
+    return await attemptClone(url, ref, url, "https");
+  } catch (e) {
+    if (!(e instanceof GitCloneError) || !e.isAuthError) throw e;
+    const sshUrl = httpsToSshUrl(url);
+    if (!sshUrl) {
+      throw new GitCloneError(formatAuthTroubleshootingGuide(url, "https"), url, false, true);
+    }
+    console.error("  ! HTTPS auth failed, retrying with SSH\u2026");
+    return attemptClone(sshUrl, ref, url, "both");
+  }
+}
+async function attemptClone(url, ref, originalUrl, transportsTried) {
+  const tempDir = await mkdtemp(join(tmpdir(), "konstruct-"));
+  const git = simpleGit({ timeout: { block: CLONE_TIMEOUT_MS } });
+  const cloneOptions = ["--depth", "1"];
+  if (ref) cloneOptions.push("--branch", ref);
+  try {
+    await git.clone(url, tempDir, cloneOptions);
+    return tempDir;
+  } catch (error) {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+    const msg = error instanceof Error ? error.message : String(error);
+    const isTimeout = msg.includes("block timeout") || msg.includes("timed out");
+    const isAuthError = msg.includes("Authentication failed") || msg.includes("could not read Username") || msg.includes("Permission denied") || msg.includes("Repository not found");
+    if (isTimeout) {
+      throw new GitCloneError(
+        `Clone timed out after 60 s \u2014 this often happens with private repos.
+` + formatAuthTroubleshootingGuide(originalUrl, transportsTried),
+        originalUrl,
+        true,
+        false
+      );
+    }
+    if (isAuthError) {
+      throw new GitCloneError(
+        formatAuthTroubleshootingGuide(originalUrl, transportsTried),
+        originalUrl,
+        false,
+        true
+      );
+    }
+    throw new GitCloneError(`Failed to clone ${url}: ${msg}`, originalUrl, false, false);
+  }
+}
+async function cleanupTempDir(dir) {
+  const { realpathSync } = await import("fs");
+  const { sep } = await import("path");
+  const normalizedDir = realpathSync(dir);
+  const normalizedTmpDir = realpathSync(tmpdir());
+  if (!normalizedDir.startsWith(normalizedTmpDir + sep) && normalizedDir !== normalizedTmpDir) {
+    throw new Error("Attempted to clean up a directory outside of the system temp directory");
+  }
+  await rm(dir, { recursive: true, force: true });
+}
+
+// src/core/discover.ts
+import { readdir, readFile } from "fs/promises";
+import { join as join2, dirname } from "path";
+import matter from "gray-matter";
+var SKILL_FILENAME = "SKILL.md";
+var MAX_DEPTH = 3;
+async function discoverSkills(rootPath, subpath) {
+  const searchPath = subpath ? join2(rootPath, subpath) : rootPath;
+  const skillFiles = await findSkillFiles(searchPath);
+  const skills = [];
+  for (const file of skillFiles) {
+    const skill = await parseSkillFile(file);
+    if (skill) skills.push(skill);
+  }
+  return skills;
+}
+async function findSkillFiles(dirPath, depth = 0) {
+  if (depth > MAX_DEPTH) return [];
+  let entries;
+  try {
+    entries = await readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    const fullPath = join2(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findSkillFiles(fullPath, depth + 1));
+    } else if (entry.name.toLowerCase() === SKILL_FILENAME.toLowerCase()) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function parseSkillFile(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  let data;
+  try {
+    const result = matter(content);
+    data = result.data;
+  } catch {
+    data = extractFrontmatterFields(content);
+  }
+  if (!data.name || !data.description) {
+    const fallbackData = extractFrontmatterFields(content);
+    if (fallbackData.name && fallbackData.description) {
+      data = fallbackData;
+    }
+  }
+  if (!data.name || !data.description) return null;
+  return {
+    name: String(data.name),
+    description: String(data.description),
+    path: dirname(filePath),
+    // the whole directory is the skill
+    metadata: data
+  };
+}
+function extractFrontmatterFields(content) {
+  const block = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!block) return {};
+  const result = {};
+  const nameMatch = block[1]?.match(/^name:\s*(.+)$/m);
+  const descMatch = block[1]?.match(/^description:\s*(.+)$/m);
+  if (nameMatch) result.name = nameMatch[1]?.trim();
+  if (descMatch) result.description = descMatch[1]?.trim();
+  return result;
+}
+
+// src/core/installer.ts
+async function installGitSkill(source, skillName, options = {}) {
+  const installDirs = await resolveInstallDirs(options);
+  let tempDir;
+  try {
+    tempDir = await cloneRepo(source.url, source.ref, { ssh: options.ssh });
+    const skills = await discoverSkills(tempDir, source.subpath);
+    let skill = skills.find((s) => s.name === skillName);
+    if (!skill && skills.length === 1) {
+      skill = skills[0];
+    }
+    if (!skill) {
+      const found = skills.map((s) => `"${s.name}"`).join(", ");
+      throw new Error(
+        `Skill "${skillName}" not found in ${source.url}${source.subpath ? `/${source.subpath}` : ""}. ` + (found ? `Found: ${found}` : "No SKILL.md files discovered.")
+      );
+    }
+    const installedPaths = await copyToAll(skill.path, skillName, installDirs);
+    return { success: true, skill: skillName, paths: installedPaths };
+  } catch (error) {
+    return {
+      success: false,
+      skill: skillName,
+      paths: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (tempDir) await cleanupTempDir(tempDir).catch(() => {
+    });
+  }
+}
+async function discoverSkillsFromSource(source, options = {}) {
+  const tempDir = await cloneRepo(source.url, source.ref, { ssh: options.ssh });
+  try {
+    const skills = await discoverSkills(tempDir, source.subpath);
+    return skills.map((s) => ({
+      name: s.name,
+      description: s.description,
+      repoPath: relative(tempDir, s.path)
+      // e.g. "skills/canvas-design"
+    }));
+  } finally {
+    await cleanupTempDir(tempDir).catch(() => {
+    });
+  }
+}
+async function checkSkillForUpdates(source, skillName, options = {}) {
+  const installDirs = await resolveInstallDirs(options);
+  const localPath = join3(installDirs[0], skillName);
+  if (!await exists(localPath)) return null;
+  let tempDir;
+  try {
+    tempDir = await cloneRepo(source.url, source.ref, { ssh: options.ssh });
+    const skills = await discoverSkills(tempDir, source.subpath);
+    let skill = skills.find((s) => s.name === skillName);
+    if (!skill && skills.length === 1) skill = skills[0];
+    if (!skill) return null;
+    const [remoteHashes, localHashes] = await Promise.all([
+      hashDirectory(skill.path),
+      hashDirectory(localPath)
+    ]);
+    const diff = diffHashes(localHashes, remoteHashes);
+    return { ...diff, upToDate: diff.added.length === 0 && diff.removed.length === 0 && diff.changed.length === 0 };
+  } finally {
+    if (tempDir) await cleanupTempDir(tempDir).catch(() => {
+    });
+  }
+}
+async function installUserSkill(source, skillName, options = {}) {
+  const installDirs = await resolveInstallDirs(options);
+  const sourcePath = resolve(source.url);
+  if (!await exists(sourcePath)) {
+    return {
+      success: false,
+      skill: skillName,
+      paths: [],
+      error: `User skill path not found: ${sourcePath}`
+    };
+  }
+  try {
+    const installedPaths = await copyToAll(sourcePath, skillName, installDirs);
+    return { success: true, skill: skillName, paths: installedPaths };
+  } catch (error) {
+    return {
+      success: false,
+      skill: skillName,
+      paths: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function resolveInstallDirs(options) {
+  if (options.customPath) return [options.customPath];
+  const config = await getEffectiveConfig(options.global ?? false);
+  const agents = options.agents ?? (config.agents.length > 0 ? config.agents : config.global?.defaultAgents ?? ["claude"]);
+  return getAgentSkillDirs(agents, options.global, process.cwd());
+}
+async function copyToAll(sourcePath, skillName, installDirs) {
+  const paths = [];
+  for (const dir of installDirs) {
+    const targetPath = join3(dir, skillName);
+    await mkdir(dir, { recursive: true });
+    await rm2(targetPath, { recursive: true, force: true });
+    await cp(sourcePath, targetPath, { recursive: true });
+    paths.push(targetPath);
+  }
+  return paths;
+}
+async function getEffectiveConfig(global) {
+  if (global) {
+    const g2 = await readConfig(process.cwd(), true);
+    return g2 ?? { version: 1, agents: ["claude"] };
+  }
+  const project = await readConfig();
+  if (project) return project;
+  const g = await readConfig(process.cwd(), true);
+  return g ?? { version: 1, agents: ["claude"] };
+}
+
+// src/cli/utils.ts
+var globalDirToSlug = new Map(
+  AGENT_REGISTRY.filter((a) => a.globalSkillsDir).map((a) => [a.globalSkillsDir, a.slug])
+);
+function formatInstallTargets(paths, customPath) {
+  if (customPath) return customPath;
+  const agents = [];
+  for (const p of paths) {
+    const parent = p.replace(/\/[^/]+$/, "");
+    const slug = globalDirToSlug.get(parent);
+    if (slug) {
+      agents.push(slug);
+      continue;
+    }
+    const localMatch = p.match(/\.([^/.]+)\/(?:skills|rules)\/[^/]+$/);
+    if (localMatch) {
+      agents.push(localMatch[1]);
+      continue;
+    }
+    agents.push(p);
+  }
+  return agents.join(", ");
+}
+
+// src/cli/components/Spinner.tsx
+import { Text } from "ink";
+import { useState, useEffect } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Spinner({ label }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => {
+      setFrame((prev) => (prev + 1) % FRAMES.length);
+    }, 80);
+    return () => clearInterval(id);
+  }, []);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: FRAMES[frame] }),
+    " ",
+    label
+  ] });
+}
+
+// src/cli/components/Select.tsx
+import { Text as Text2, Box, useInput } from "ink";
+import { useState as useState2 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function Select({ prompt, items, onSelect }) {
+  const [cursor, setCursor] = useState2(0);
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setCursor((prev) => (prev - 1 + items.length) % items.length);
+    } else if (key.downArrow) {
+      setCursor((prev) => (prev + 1) % items.length);
+    } else if (key.return) {
+      onSelect(cursor);
+    }
+  });
+  if (!process.stdin.isTTY) {
+    return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: prompt }),
+      items.map((item, i) => /* @__PURE__ */ jsxs2(Text2, { children: [
+        "  ",
+        i + 1,
+        ". ",
+        item
+      ] }, i))
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: prompt }),
+    items.map((item, i) => /* @__PURE__ */ jsxs2(Text2, { children: [
+      "  ",
+      i === cursor ? /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u203A" }) : " ",
+      " ",
+      i === cursor ? /* @__PURE__ */ jsx2(Text2, { bold: true, children: item }) : item
+    ] }, i)),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  \u2191\u2193 move  enter select" })
+  ] });
+}
+
+// src/cli/commands/add.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function AddApp({ source, options: initialOptions }) {
+  const { exit } = useApp();
+  const [phase, setPhase] = useState3("parsing");
+  const [messages, setMessages] = useState3([]);
+  const [spinnerLabel, setSpinnerLabel] = useState3("");
+  const [skills, setSkills] = useState3([]);
+  const [parsed, setParsed] = useState3(null);
+  const [options, setOptions] = useState3(initialOptions);
+  useEffect2(() => {
+    if (phase === "done") exit();
+  }, [phase, exit]);
+  function finish() {
+    setSpinnerLabel("");
+    setPhase("done");
+  }
+  function addMsg(variant, text) {
+    setMessages((prev) => [...prev, { variant, text }]);
+  }
+  const [initialized, setInitialized] = useState3(false);
+  if (!initialized) {
+    setInitialized(true);
+    (async () => {
+      let parsedSource;
+      try {
+        parsedSource = parseSource(source);
+      } catch (e) {
+        addMsg("error", e instanceof Error ? e.message : String(e));
+        finish();
+        return;
+      }
+      setParsed(parsedSource);
+      if (!options.global) {
+        const localManifest = await readManifest(process.cwd());
+        if (!localManifest) {
+          addMsg("warn", "No skills.json found in the current directory.");
+          setPhase("no-manifest");
+          return;
+        }
+      }
+      await startInstall(parsedSource, options);
+    })();
+  }
+  const onNoManifestSelect = useCallback(async (index) => {
+    const opts = { ...options };
+    if (index === 0) {
+      opts.global = true;
+      setOptions(opts);
+    } else {
+      const { initCommand: initCommand2 } = await import("./init-CJ7EZ75L.js");
+      await initCommand2();
+    }
+    if (parsed) await startInstall(parsed, opts);
+  }, [options, parsed]);
+  async function startInstall(parsedSource, opts) {
+    if (parsedSource.type === "file" || opts.user) {
+      if (opts.user && parsedSource.type !== "file") {
+        addMsg("error", "--user flag requires a file: source (e.g. file:./my-skill)");
+        finish();
+        return;
+      }
+      const skillName = deriveSkillName(source, parsedSource);
+      setSpinnerLabel(`Adding "${skillName}"\u2026`);
+      setPhase("installing");
+      const result = await installUserSkill(parsedSource, skillName, {
+        global: opts.global,
+        customPath: opts.path
+      });
+      if (!result.success) {
+        addMsg("error", result.error ?? "Unknown error");
+        finish();
+        return;
+      }
+      addMsg("success", `Added "${skillName}"`);
+      await addSkillToManifest(skillName, source, {
+        isUserSkill: true,
+        cwd: opts.global ? KONSTRUCT_DIR : void 0,
+        customPath: opts.path
+      });
+      addMsg("info", `Installed to: ${formatInstallTargets(result.paths, opts.path)}`);
+      addMsg("info", "Added to skills.json");
+      finish();
+      return;
+    }
+    setSpinnerLabel("Cloning and discovering skills\u2026");
+    setPhase("discovering");
+    let discovered;
+    try {
+      discovered = await discoverSkillsFromSource(parsedSource, { ssh: opts.ssh });
+    } catch (e) {
+      addMsg("error", e instanceof Error ? e.message : String(e));
+      finish();
+      return;
+    }
+    addMsg("success", "Discovery complete");
+    if (discovered.length === 0) {
+      addMsg("error", "No SKILL.md files found in that repository.");
+      finish();
+      return;
+    }
+    if (discovered.length === 1) {
+      addMsg("info", `Found 1 skill: "${discovered[0].name}"`);
+      await installPicks(parsedSource, opts, [discovered[0]], discovered);
+    } else {
+      setSpinnerLabel("");
+      setSkills(discovered);
+      setPhase("selecting");
+    }
+  }
+  const onSkillsConfirm = useCallback(async (indices) => {
+    if (indices.length === 0) {
+      addMsg("info", "Nothing selected.");
+      finish();
+      return;
+    }
+    const picks = indices.map((i) => skills[i]);
+    if (parsed) await installPicks(parsed, options, picks, skills);
+  }, [skills, parsed, options]);
+  async function installPicks(parsedSource, opts, picks, allSkills) {
+    setPhase("installing");
+    let installed = 0;
+    for (const chosen of picks) {
+      const persistedSource = parsedSource.subpath || allSkills.length === 1 ? source : serializeSource(parsedSource, chosen.repoPath);
+      const installSource = {
+        ...parsedSource,
+        subpath: chosen.repoPath || void 0
+      };
+      setSpinnerLabel(`Installing "${chosen.name}"\u2026`);
+      const result = await installGitSkill(installSource, chosen.name, {
+        global: opts.global,
+        customPath: opts.path,
+        ssh: opts.ssh
+      });
+      if (!result.success) {
+        addMsg("error", result.error ?? "Unknown error");
+        continue;
+      }
+      addMsg("success", `Installed "${chosen.name}"`);
+      await addSkillToManifest(chosen.name, persistedSource, {
+        cwd: opts.global ? KONSTRUCT_DIR : void 0,
+        customPath: opts.path
+      });
+      addMsg("info", `Installed to: ${formatInstallTargets(result.paths, opts.path)}`);
+      installed++;
+    }
+    addMsg("info", `${installed}/${picks.length} skill(s) added to skills.json`);
+    finish();
+  }
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Banner, {}),
+    messages.map((m, i) => /* @__PURE__ */ jsx3(StatusMessage, { variant: m.variant, children: m.text }, i)),
+    phase === "no-manifest" && /* @__PURE__ */ jsx3(
+      Select,
+      {
+        prompt: "How would you like to proceed?",
+        items: ["Install globally (default agents)", "Initialize this project and install here"],
+        onSelect: onNoManifestSelect
+      }
+    ),
+    phase === "selecting" && skills.length > 0 && /* @__PURE__ */ jsx3(
+      MultiSelect,
+      {
+        prompt: "Select skills to install:",
+        items: skills.map((s) => s.name),
+        onConfirm: onSkillsConfirm
+      }
+    ),
+    (phase === "discovering" || phase === "installing") && spinnerLabel && /* @__PURE__ */ jsx3(Spinner, { label: spinnerLabel })
+  ] });
+}
+function serializeSource(parsed, repoPath) {
+  const ref = parsed.ref ? `#${parsed.ref}` : "";
+  if (parsed.type === "github") {
+    const match = parsed.url.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (match) return `github:${match[1]}/${match[2]}/${repoPath}${ref}`;
+  }
+  if (parsed.type === "gitlab") {
+    const match = parsed.url.match(/gitlab\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (match) return `gitlab:${match[1]}/${match[2]}/${repoPath}${ref}`;
+  }
+  return `git:${parsed.url}${ref}`;
+}
+function deriveSkillName(source, parsed) {
+  if (parsed.subpath) {
+    const segments = parsed.subpath.split("/").filter(Boolean);
+    if (segments.length > 0) return segments[segments.length - 1];
+  }
+  if (source.startsWith("file:")) {
+    const path = source.slice("file:".length).replace(/\/+$/, "");
+    const segments = path.split("/").filter(Boolean);
+    return segments[segments.length - 1] ?? "skill";
+  }
+  try {
+    const url = new URL(parsed.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    const repo = parts[parts.length - 1]?.replace(/\.git$/, "");
+    return repo ?? "skill";
+  } catch {
+    return "skill";
+  }
+}
+async function addCommand(source, options) {
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx3(AddApp, { source, options }));
+  await waitUntilExit();
+}
+
+// src/cli/commands/install.tsx
+import { render as render2, Text as Text3, Box as Box3, Static, useApp as useApp2 } from "ink";
+import { useEffect as useEffect3, useState as useState4 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function InstallApp({ options }) {
+  const { exit } = useApp2();
+  const [completed, setCompleted] = useState4([]);
+  const [current, setCurrent] = useState4();
+  const [total, setTotal] = useState4(0);
+  const [fatalError, setFatalError] = useState4();
+  const [done, setDone] = useState4(false);
+  useEffect3(() => {
+    if (done) exit();
+  }, [done, exit]);
+  useEffect3(() => {
+    (async () => {
+      const manifest = await readManifest();
+      if (!manifest) {
+        setFatalError('No skills.json found. Run "konstruct init" first.');
+        setDone(true);
+        return;
+      }
+      const gitEntries = Object.entries(manifest.skills);
+      const userEntries = Object.entries(manifest.userSkills ?? {});
+      const count = gitEntries.length + userEntries.length;
+      setTotal(count);
+      if (count === 0) {
+        setDone(true);
+        return;
+      }
+      for (const [name, entry] of gitEntries) {
+        setCurrent(name);
+        const { source, customPath } = parseSkillEntry(entry);
+        const parsed = parseSource(source);
+        const result = await installGitSkill(parsed, name, {
+          global: options.global,
+          ssh: options.ssh,
+          customPath
+        });
+        setCompleted((prev) => [
+          ...prev,
+          {
+            name,
+            ok: result.success,
+            detail: result.success ? `\u2192 ${formatInstallTargets(result.paths, customPath)}` : result.error ?? "Unknown error"
+          }
+        ]);
+      }
+      for (const [name, entry] of userEntries) {
+        setCurrent(name);
+        const { source, customPath } = parseSkillEntry(entry);
+        const parsed = parseSource(source);
+        const result = await installUserSkill(parsed, name, {
+          global: options.global,
+          customPath
+        });
+        setCompleted((prev) => [
+          ...prev,
+          {
+            name,
+            ok: result.success,
+            detail: result.success ? `\u2192 ${formatInstallTargets(result.paths, customPath)}` : result.error ?? "Unknown error"
+          }
+        ]);
+      }
+      setCurrent(void 0);
+      setDone(true);
+    })();
+  }, []);
+  if (fatalError) {
+    return /* @__PURE__ */ jsx4(StatusMessage, { variant: "error", children: fatalError });
+  }
+  if (total === 0 && done) {
+    return /* @__PURE__ */ jsxs4(StatusMessage, { variant: "info", children: [
+      'No skills in manifest. Use "konstruct add ',
+      "<source>",
+      '" to add some.'
+    ] });
+  }
+  const failures = completed.filter((c) => !c.ok).length;
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
+    total > 0 && /* @__PURE__ */ jsxs4(StatusMessage, { variant: "info", children: [
+      "Installing ",
+      total,
+      " skill(s)\u2026"
+    ] }),
+    /* @__PURE__ */ jsx4(Static, { items: completed, children: (item) => /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(StatusMessage, { variant: item.ok ? "success" : "error", children: item.name }),
+      item.ok ? /* @__PURE__ */ jsxs4(Text3, { children: [
+        "  ",
+        /* @__PURE__ */ jsx4(Text3, { color: "cyan", children: "\u2139" }),
+        " ",
+        item.detail
+      ] }) : /* @__PURE__ */ jsxs4(Text3, { children: [
+        "  ",
+        /* @__PURE__ */ jsx4(Text3, { color: "red", children: "\u2717" }),
+        " ",
+        item.detail
+      ] })
+    ] }, item.name) }),
+    current && /* @__PURE__ */ jsx4(Spinner, { label: current }),
+    done && /* @__PURE__ */ jsx4(Box3, { marginTop: 1, children: failures === 0 ? /* @__PURE__ */ jsxs4(StatusMessage, { variant: "success", children: [
+      "All ",
+      total,
+      " skill(s) installed."
+    ] }) : /* @__PURE__ */ jsxs4(StatusMessage, { variant: "error", children: [
+      failures,
+      " of ",
+      total,
+      " skill(s) failed."
+    ] }) })
+  ] });
+}
+async function installCommand(options) {
+  const { waitUntilExit } = render2(/* @__PURE__ */ jsx4(InstallApp, { options }));
+  await waitUntilExit();
+}
+
+// src/cli/commands/remove.tsx
+import { render as render3, Box as Box4, useApp as useApp3 } from "ink";
+import { useEffect as useEffect4, useState as useState5 } from "react";
+import { rm as rm3 } from "fs/promises";
+import { join as join4 } from "path";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function RemoveApp({ names, options }) {
+  const { exit } = useApp3();
+  const [results, setResults] = useState5([]);
+  const [done, setDone] = useState5(false);
+  const [fatalError, setFatalError] = useState5();
+  useEffect4(() => {
+    if (done) exit();
+  }, [done, exit]);
+  useEffect4(() => {
+    (async () => {
+      const isGlobal = options.global ?? false;
+      const manifestCwd = isGlobal ? KONSTRUCT_DIR : void 0;
+      const manifest = await readManifest(manifestCwd);
+      if (!isGlobal && !manifest) {
+        setFatalError("No skills.json found.");
+        setDone(true);
+        return;
+      }
+      const config = await readConfig(process.cwd(), isGlobal);
+      const agents = config && config.agents.length > 0 ? config.agents : config?.global?.defaultAgents ?? ["claude"];
+      const dirs = getAgentSkillDirs(agents, isGlobal);
+      const statuses = [];
+      for (const name of names) {
+        const inManifest = manifest ? name in manifest.skills || (manifest.userSkills ? name in manifest.userSkills : false) : false;
+        let onDisk = false;
+        if (isGlobal) {
+          for (const dir of dirs) {
+            if (await exists(join4(dir, name))) {
+              onDisk = true;
+              break;
+            }
+          }
+        }
+        if (!inManifest && !onDisk) {
+          statuses.push({
+            name,
+            status: "error",
+            message: `Skill "${name}" not found${isGlobal ? " in global skill directories" : " in skills.json"}`
+          });
+          continue;
+        }
+        if (inManifest) await removeSkillFromManifest(name, manifestCwd);
+        for (const dir of dirs) {
+          await rm3(join4(dir, name), { recursive: true, force: true }).catch(() => {
+          });
+        }
+        statuses.push({ name, status: "success", message: `Removed "${name}"` });
+      }
+      setResults(statuses);
+      setDone(true);
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
+    fatalError && /* @__PURE__ */ jsx5(StatusMessage, { variant: "error", children: fatalError }),
+    results.map((r) => /* @__PURE__ */ jsx5(StatusMessage, { variant: r.status === "success" ? "success" : "error", children: r.message }, r.name)),
+    done && !fatalError && results.length > 1 && /* @__PURE__ */ jsxs5(StatusMessage, { variant: "info", children: [
+      results.filter((r) => r.status === "success").length,
+      "/",
+      names.length,
+      " skill(s) removed"
+    ] })
+  ] });
+}
+async function removeCommand(names, options = {}) {
+  const { waitUntilExit } = render3(/* @__PURE__ */ jsx5(RemoveApp, { names, options }));
+  await waitUntilExit();
+}
+
+// src/cli/commands/list.tsx
+import { render as render4, Text as Text5, Box as Box5 } from "ink";
+import { useEffect as useEffect5, useState as useState6 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function ListApp({ options }) {
+  const [state, setState] = useState6({
+    installed: [],
+    user: [],
+    untracked: [],
+    done: false
+  });
+  useEffect5(() => {
+    (async () => {
+      const isGlobal = options.global ?? false;
+      const manifest = await readManifest(isGlobal ? KONSTRUCT_DIR : void 0);
+      if (!manifest) {
+        setState((s) => ({ ...s, error: 'No skills.json found. Run "konstruct init" first.', done: true }));
+        return;
+      }
+      const config = await readConfig(process.cwd(), isGlobal);
+      const agents = config && config.agents.length > 0 ? config.agents : config?.global?.defaultAgents ?? ["claude"];
+      const dirs = getAgentSkillDirs(agents, isGlobal);
+      const installedEntries = Object.entries(manifest.skills);
+      const userEntries = Object.entries(manifest.userSkills ?? {});
+      const manifestNames = /* @__PURE__ */ new Set([
+        ...installedEntries.map(([name]) => name),
+        ...userEntries.map(([name]) => name)
+      ]);
+      const untracked = [];
+      for (const dir of dirs) {
+        const discovered = await discoverSkills(dir);
+        for (const skill of discovered) {
+          if (!manifestNames.has(skill.name) && !untracked.some((u) => u.name === skill.name)) {
+            untracked.push({ name: skill.name, path: skill.path });
+          }
+        }
+      }
+      setState({
+        installed: installedEntries,
+        user: userEntries,
+        untracked,
+        done: true
+      });
+    })();
+  }, []);
+  if (state.error) {
+    return /* @__PURE__ */ jsx6(StatusMessage, { variant: "error", children: state.error });
+  }
+  if (!state.done) return null;
+  const hasAnything = state.installed.length > 0 || state.user.length > 0 || state.untracked.length > 0;
+  if (!hasAnything) {
+    return /* @__PURE__ */ jsxs6(StatusMessage, { variant: "info", children: [
+      'No skills found. Use "konstruct add ',
+      "<source>",
+      '" to add some.'
+    ] });
+  }
+  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", children: [
+    state.installed.length > 0 && /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(Text5, { bold: true, children: "Installed skills:" }),
+      state.installed.map(([name]) => /* @__PURE__ */ jsxs6(Text5, { children: [
+        "  ",
+        /* @__PURE__ */ jsx6(Text5, { color: "cyan", children: name })
+      ] }, name))
+    ] }),
+    state.user.length > 0 && /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(Text5, { bold: true, children: "User skills:" }),
+      state.user.map(([name]) => /* @__PURE__ */ jsxs6(Text5, { children: [
+        "  ",
+        /* @__PURE__ */ jsx6(Text5, { color: "cyan", children: name })
+      ] }, name))
+    ] }),
+    state.untracked.length > 0 && /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(Text5, { bold: true, children: "Untracked skills:" }),
+      state.untracked.map(({ name }) => /* @__PURE__ */ jsxs6(Text5, { children: [
+        "  ",
+        /* @__PURE__ */ jsx6(Text5, { color: "cyan", children: name })
+      ] }, name))
+    ] }),
+    /* @__PURE__ */ jsx6(Text5, { children: "" })
+  ] });
+}
+async function listCommand(options = {}) {
+  const { waitUntilExit } = render4(/* @__PURE__ */ jsx6(ListApp, { options }));
+  await waitUntilExit();
+}
+
+// src/cli/commands/update.tsx
+import { render as render5, Text as Text7, Box as Box7, Static as Static2, useApp as useApp4 } from "ink";
+import { useEffect as useEffect6, useState as useState7 } from "react";
+
+// src/cli/components/DiffView.tsx
+import { Text as Text6, Box as Box6 } from "ink";
+import { jsxs as jsxs7 } from "react/jsx-runtime";
+function DiffView({ diff }) {
+  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", paddingLeft: 4, children: [
+    diff.added.map((f, i) => /* @__PURE__ */ jsxs7(Text6, { color: "green", children: [
+      "+ ",
+      f
+    ] }, `a-${i}`)),
+    diff.changed.map((f, i) => /* @__PURE__ */ jsxs7(Text6, { color: "yellow", children: [
+      "~ ",
+      f
+    ] }, `c-${i}`)),
+    diff.removed.map((f, i) => /* @__PURE__ */ jsxs7(Text6, { color: "red", children: [
+      "- ",
+      f
+    ] }, `r-${i}`))
+  ] });
+}
+
+// src/cli/commands/update.tsx
+import { jsx as jsx7, jsxs as jsxs8 } from "react/jsx-runtime";
+function UpdateApp({ options }) {
+  const { exit } = useApp4();
+  const [completed, setCompleted] = useState7([]);
+  const [current, setCurrent] = useState7();
+  const [total, setTotal] = useState7(0);
+  const [fatalError, setFatalError] = useState7();
+  const [done, setDone] = useState7(false);
+  useEffect6(() => {
+    if (done) exit();
+  }, [done, exit]);
+  useEffect6(() => {
+    (async () => {
+      const manifest = await readManifest(options.global ? KONSTRUCT_DIR : void 0);
+      if (!manifest) {
+        setFatalError('No skills.json found. Run "konstruct init" first.');
+        setDone(true);
+        return;
+      }
+      const gitEntries = Object.entries(manifest.skills);
+      setTotal(gitEntries.length);
+      if (gitEntries.length === 0) {
+        setDone(true);
+        return;
+      }
+      for (const [name, entry] of gitEntries) {
+        setCurrent(`${name} \u2014 checking\u2026`);
+        const { source, customPath } = parseSkillEntry(entry);
+        const parsed = parseSource(source);
+        let diff;
+        try {
+          diff = await checkSkillForUpdates(parsed, name, {
+            global: options.global,
+            ssh: options.ssh,
+            customPath
+          });
+        } catch (e) {
+          setCompleted((prev) => [
+            ...prev,
+            { name, status: "failed", detail: e instanceof Error ? e.message : String(e) }
+          ]);
+          continue;
+        }
+        if (diff === null) {
+          setCurrent(`${name} \u2014 installing\u2026`);
+          const result2 = await installGitSkill(parsed, name, {
+            global: options.global,
+            ssh: options.ssh,
+            customPath
+          });
+          setCompleted((prev) => [
+            ...prev,
+            result2.success ? { name, status: "installed", detail: `installed \u2192 ${formatInstallTargets(result2.paths, customPath)}` } : { name, status: "failed", detail: result2.error }
+          ]);
+          continue;
+        }
+        if (diff.upToDate) {
+          setCompleted((prev) => [...prev, { name, status: "up-to-date" }]);
+          continue;
+        }
+        setCurrent(`${name} \u2014 updating\u2026`);
+        const result = await installGitSkill(parsed, name, {
+          global: options.global,
+          ssh: options.ssh,
+          customPath
+        });
+        setCompleted((prev) => [
+          ...prev,
+          result.success ? { name, status: "updated", diff } : { name, status: "failed", detail: result.error }
+        ]);
+      }
+      setCurrent(void 0);
+      setDone(true);
+    })();
+  }, []);
+  if (fatalError) {
+    return /* @__PURE__ */ jsx7(StatusMessage, { variant: "error", children: fatalError });
+  }
+  if (total === 0 && done) {
+    return /* @__PURE__ */ jsx7(StatusMessage, { variant: "info", children: "No git skills to update." });
+  }
+  const updated = completed.filter((c) => c.status === "updated" || c.status === "installed").length;
+  const upToDate = completed.filter((c) => c.status === "up-to-date").length;
+  const failures = completed.filter((c) => c.status === "failed").length;
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
+    total > 0 && /* @__PURE__ */ jsxs8(StatusMessage, { variant: "info", children: [
+      "Checking ",
+      total,
+      " git skill(s)\u2026 (userSkills are skipped)"
+    ] }),
+    /* @__PURE__ */ jsx7(Static2, { items: completed, children: (item) => /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs8(StatusMessage, { variant: item.status === "failed" ? "error" : "success", children: [
+        item.name,
+        item.status === "up-to-date" && /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " up to date" }),
+        item.detail && ` ${item.detail}`
+      ] }),
+      item.diff && /* @__PURE__ */ jsx7(DiffView, { diff: item.diff })
+    ] }, item.name) }),
+    current && /* @__PURE__ */ jsx7(Spinner, { label: current }),
+    done && /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", marginTop: 1, children: [
+      failures > 0 && /* @__PURE__ */ jsxs8(StatusMessage, { variant: "error", children: [
+        failures,
+        " skill(s) failed."
+      ] }),
+      updated > 0 && /* @__PURE__ */ jsxs8(StatusMessage, { variant: "success", children: [
+        updated,
+        " skill(s) updated."
+      ] }),
+      upToDate > 0 && /* @__PURE__ */ jsxs8(StatusMessage, { variant: "info", children: [
+        upToDate,
+        " skill(s) already up to date."
+      ] })
+    ] })
+  ] });
+}
+async function updateCommand(options = {}) {
+  const { waitUntilExit } = render5(/* @__PURE__ */ jsx7(UpdateApp, { options }));
+  await waitUntilExit();
+}
+
+// src/cli/commands/defaults.tsx
+import { render as render6, Box as Box8, useApp as useApp5 } from "ink";
+import { useState as useState8, useCallback as useCallback2, useEffect as useEffect7 } from "react";
+import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
+function DefaultsApp() {
+  const { exit } = useApp5();
+  const [phase, setPhase] = useState8("scope");
+  const [isGlobal, setIsGlobal] = useState8(false);
+  const [hasLocalManifest, setHasLocalManifest] = useState8(false);
+  const [currentAgents, setCurrentAgents] = useState8([]);
+  const [config, setConfig] = useState8(null);
+  const [orderedSlugs, setOrderedSlugs] = useState8([]);
+  const [labels, setLabels] = useState8([]);
+  const [result, setResult] = useState8();
+  useEffect7(() => {
+    if (phase === "done") exit();
+  }, [phase, exit]);
+  const [initialized, setInitialized] = useState8(false);
+  if (!initialized) {
+    setInitialized(true);
+    (async () => {
+      const localManifest = await readManifest(process.cwd());
+      if (localManifest) {
+        setHasLocalManifest(true);
+      } else {
+        setIsGlobal(true);
+        await loadConfig(true);
+      }
+    })();
+  }
+  async function loadConfig(global) {
+    const cwd = process.cwd();
+    const cfg = await readConfig(cwd, global);
+    setConfig(cfg);
+    const agents = global ? cfg?.global?.defaultAgents ?? cfg?.agents ?? [] : cfg?.agents ?? [];
+    setCurrentAgents(agents);
+    const { ordered, labels: lbls } = getAgentLabels();
+    setOrderedSlugs(ordered);
+    setLabels(lbls);
+    setPhase("display");
+  }
+  const onScopeSelect = useCallback2(async (index) => {
+    const global = index === 1;
+    setIsGlobal(global);
+    await loadConfig(global);
+  }, []);
+  const onAgentsConfirm = useCallback2(async (indices) => {
+    const agents = indices.length === 0 ? ["claude"] : indices.map((i) => orderedSlugs[i]);
+    const scope = isGlobal ? "global" : "project";
+    const cwd = process.cwd();
+    if (config) {
+      if (isGlobal) {
+        if (!config.global) config.global = { defaultAgents: agents };
+        else config.global.defaultAgents = agents;
+      } else {
+        config.agents = agents;
+      }
+      await writeConfig(config, cwd, isGlobal);
+    } else {
+      const newConfig = {
+        version: 1,
+        agents: isGlobal ? [] : agents,
+        ...isGlobal && { global: { defaultAgents: agents } }
+      };
+      await writeConfig(newConfig, cwd, isGlobal);
+    }
+    setResult({ agents, scope });
+    setPhase("done");
+  }, [config, isGlobal, orderedSlugs]);
+  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", children: [
+    phase === "scope" && hasLocalManifest && /* @__PURE__ */ jsx8(
+      Select,
+      {
+        prompt: "Update project defaults or global defaults?",
+        items: ["Project", "Global"],
+        onSelect: onScopeSelect
+      }
+    ),
+    phase === "scope" && !hasLocalManifest && /* @__PURE__ */ jsx8(StatusMessage, { variant: "info", children: "No skills.json in current directory \u2014 updating global defaults." }),
+    phase === "display" && /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: currentAgents.length > 0 ? /* @__PURE__ */ jsxs9(StatusMessage, { variant: "info", children: [
+      "Current default agents: ",
+      currentAgents.join(", ")
+    ] }) : /* @__PURE__ */ jsx8(StatusMessage, { variant: "warn", children: "No default agents configured." }) }),
+    (phase === "display" || phase === "select-agents") && labels.length > 0 && /* @__PURE__ */ jsx8(
+      MultiSelect,
+      {
+        prompt: "Select your default agent(s)",
+        items: labels,
+        onConfirm: onAgentsConfirm
+      }
+    ),
+    phase === "done" && result && /* @__PURE__ */ jsxs9(StatusMessage, { variant: "success", children: [
+      "Updated ",
+      result.scope,
+      " default agents: ",
+      result.agents.join(", ")
+    ] })
+  ] });
+}
+async function defaultsCommand() {
+  const { waitUntilExit } = render6(/* @__PURE__ */ jsx8(DefaultsApp, {}));
+  await waitUntilExit();
+}
+
+// src/cli/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+function getVersion() {
+  const candidates = [
+    resolve2(__dirname, "..", "..", "package.json"),
+    resolve2(__dirname, "..", "package.json")
+  ];
+  for (const pkgPath of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+var program = new Command();
+program.name("konstruct").description("Package manager for AI agent skills").version(getVersion());
+program.command("init").description("Initialize skills.json and konstruct.config.json").option("-g, --global", "Initialize global configuration (~/.konstruct/) instead of project-local").action(initCommand);
+program.command("install").description("Install all skills from skills.json").option("-g, --global", "Install globally (~/) instead of project-local").option("-s, --ssh", "Use SSH for cloning (default: HTTPS with auto-retry on auth failure)").action(installCommand);
+program.command("add <source>").description("Add a skill from a git or local source").option("-g, --global", "Install globally").option("--user", "Add as a userSkill (local, never auto-updated)").option("--path <path>", "Custom installation path").option("-s, --ssh", "Use SSH for cloning (default: HTTPS with auto-retry on auth failure)").action(addCommand);
+program.command("remove <names...>").description("Remove one or more skills by name").option("-g, --global", "Remove from global (~/) directories instead of project-local").action(removeCommand);
+program.command("list").description("List all skills in the current manifest").option("-g, --global", "List skills from the global manifest instead of project-local").action(listCommand);
+program.command("update").description("Re-install git skills at their manifest refs (skips userSkills)").option("-g, --global", "Update in global (~/) directories instead of project-local").option("-s, --ssh", "Use SSH for cloning (default: HTTPS with auto-retry on auth failure)").action(updateCommand);
+program.command("defaults").description("View and update default agent preferences").action(defaultsCommand);
+program.parseAsync().catch((err) => {
+  console.error(pc.red("\u2717"), err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});