konstruct 0.1.0

package/dist/chunk-MYTZHNE6.js

@@ -0,0 +1,696 @@
+// src/cli/commands/init.tsx
+import { render, Box as Box3, useApp } from "ink";
+import { useState as useState2, useCallback, useEffect } from "react";
+
+// src/core/manifest.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { join as join2, basename } from "path";
+
+// src/utils/fs.ts
+import { access, constants, readdir, readFile } from "fs/promises";
+import { join, relative } from "path";
+import { createHash } from "crypto";
+async function exists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hashDirectory(dirPath) {
+  const result = /* @__PURE__ */ new Map();
+  await walkAndHash(dirPath, dirPath, result);
+  return result;
+}
+async function walkAndHash(root, current, out) {
+  let entries;
+  try {
+    entries = await readdir(current, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join(current, entry.name);
+    if (entry.isDirectory()) {
+      await walkAndHash(root, full, out);
+    } else {
+      const content = await readFile(full);
+      const hash = createHash("sha256").update(content).digest("hex");
+      out.set(relative(root, full), hash);
+    }
+  }
+}
+function diffHashes(local, remote) {
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [path, hash] of remote) {
+    if (!local.has(path)) {
+      added.push(path);
+    } else if (local.get(path) !== hash) {
+      changed.push(path);
+    }
+  }
+  for (const path of local.keys()) {
+    if (!remote.has(path)) {
+      removed.push(path);
+    }
+  }
+  return { added, removed, changed };
+}
+
+// src/core/source-parser.ts
+function parseSource(source) {
+  if (source.startsWith("github:")) {
+    return parseGitHub(source.slice("github:".length));
+  }
+  if (source.startsWith("gitlab:")) {
+    return parseGenericGit("gitlab", source.slice("gitlab:".length));
+  }
+  if (source.startsWith("git:")) {
+    return parseGenericGit("git", source.slice("git:".length));
+  }
+  if (source.startsWith("file:")) {
+    return { type: "file", url: source.slice("file:".length) };
+  }
+  if (!source.includes("://") && source.includes("/")) {
+    return parseGitHub(source);
+  }
+  throw new Error(
+    `Unknown source format: "${source}".
+
+  Supported formats:
+    github:owner/repo#ref        GitHub repo (or owner/repo shorthand)
+    gitlab:owner/repo#ref        GitLab repo
+    git:https://host/repo.git    Arbitrary git URL
+    file:./path/to/skill         Local directory
+`
+  );
+}
+function parseGitHub(input) {
+  const { base, ref } = splitRef(input);
+  const segments = base.split("/");
+  if (segments.length < 2) {
+    throw new Error(`Invalid github source: "github:${input}" \u2014 expected at least owner/repo`);
+  }
+  const owner = segments[0];
+  const repo = segments[1].replace(/\.git$/, "");
+  const subpath = segments.length > 2 ? segments.slice(2).join("/") : void 0;
+  return {
+    type: "github",
+    url: `https://github.com/${owner}/${repo}.git`,
+    ref,
+    subpath
+  };
+}
+function parseGenericGit(type, input) {
+  const { base, ref } = splitRef(input);
+  if (type === "git") {
+    return { type: "git", url: base.endsWith(".git") ? base : base + ".git", ref };
+  }
+  const segments = base.split("/");
+  if (segments.length < 2) {
+    throw new Error(`Invalid gitlab source: "gitlab:${input}" \u2014 expected at least owner/repo`);
+  }
+  const owner = segments[0];
+  const repo = segments[1].replace(/\.git$/, "");
+  const subpath = segments.length > 2 ? segments.slice(2).join("/") : void 0;
+  return {
+    type: "gitlab",
+    url: `https://gitlab.com/${owner}/${repo}.git`,
+    ref,
+    subpath
+  };
+}
+function splitRef(input) {
+  const hashIndex = input.lastIndexOf("#");
+  if (hashIndex === -1) return { base: input, ref: void 0 };
+  return {
+    base: input.slice(0, hashIndex),
+    ref: input.slice(hashIndex + 1) || void 0
+  };
+}
+
+// src/core/manifest.ts
+var MANIFEST_FILENAME = "skills.json";
+function parseSkillEntry(entry) {
+  return { source: entry.source, customPath: entry.path };
+}
+async function readManifest(cwd = process.cwd()) {
+  const manifestPath = join2(cwd, MANIFEST_FILENAME);
+  if (!await exists(manifestPath)) return null;
+  const raw = await readFile2(manifestPath, "utf-8");
+  let manifest;
+  try {
+    manifest = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Invalid JSON in ${manifestPath}: ${e instanceof Error ? e.message : e}`);
+  }
+  validateManifest(manifest);
+  return manifest;
+}
+async function writeManifest(manifest, cwd = process.cwd()) {
+  const manifestPath = join2(cwd, MANIFEST_FILENAME);
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+async function addSkillToManifest(skillName, source, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  let manifest = await readManifest(cwd);
+  if (!manifest) {
+    manifest = {
+      name: basename(cwd),
+      version: "1.0.0",
+      skills: {}
+    };
+  }
+  const entry = {
+    source,
+    ...options.customPath && { path: options.customPath }
+  };
+  if (options.isUserSkill) {
+    if (!manifest.userSkills) manifest.userSkills = {};
+    manifest.userSkills[skillName] = entry;
+  } else {
+    manifest.skills[skillName] = entry;
+  }
+  await writeManifest(manifest, cwd);
+}
+async function removeSkillFromManifest(skillName, cwd = process.cwd()) {
+  const manifest = await readManifest(cwd);
+  if (!manifest) return false;
+  let removed = false;
+  if (manifest.skills[skillName]) {
+    delete manifest.skills[skillName];
+    removed = true;
+  }
+  if (manifest.userSkills?.[skillName]) {
+    delete manifest.userSkills[skillName];
+    removed = true;
+  }
+  if (removed) await writeManifest(manifest, cwd);
+  return removed;
+}
+function validateManifest(manifest) {
+  if (!manifest || typeof manifest !== "object") {
+    throw new Error("Invalid skills.json: must be a JSON object");
+  }
+  const m = manifest;
+  if (typeof m.name !== "string") {
+    throw new Error('Invalid skills.json: "name" must be a string');
+  }
+  if (typeof m.version !== "string") {
+    throw new Error('Invalid skills.json: "version" must be a string');
+  }
+  if (!m.skills || typeof m.skills !== "object" || Array.isArray(m.skills)) {
+    throw new Error('Invalid skills.json: "skills" must be an object');
+  }
+  for (const [name, entry] of Object.entries(m.skills)) {
+    validateSkillEntry(entry, name, false);
+  }
+  if (m.userSkills !== void 0) {
+    if (typeof m.userSkills !== "object" || Array.isArray(m.userSkills)) {
+      throw new Error('Invalid skills.json: "userSkills" must be an object');
+    }
+    for (const [name, entry] of Object.entries(m.userSkills)) {
+      validateSkillEntry(entry, name, true);
+    }
+  }
+}
+function validateSkillEntry(entry, name, isUserSkill) {
+  if (!entry || typeof entry !== "object") {
+    throw new Error(`Invalid skills.json: ${isUserSkill ? "userSkill" : "skill"} "${name}" must be an object`);
+  }
+  const e = entry;
+  if (typeof e.source !== "string") {
+    throw new Error(`Invalid skills.json: ${isUserSkill ? "userSkill" : "skill"} "${name}" must have a "source" string`);
+  }
+  if (e.path !== void 0 && typeof e.path !== "string") {
+    throw new Error(`Invalid skills.json: ${isUserSkill ? "userSkill" : "skill"} "${name}" path must be a string if provided`);
+  }
+  const parsed = parseSource(e.source);
+  if (isUserSkill && parsed.type !== "file") {
+    throw new Error(`Invalid skills.json: userSkill "${name}" must use the file: prefix`);
+  }
+}
+
+// src/core/config.ts
+import { readFile as readFile3, writeFile as writeFile2, mkdir } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+var CONFIG_FILENAME = "konstruct.config.json";
+var KONSTRUCT_DIR = join3(homedir(), ".konstruct");
+var home = homedir();
+var configHome = process.env.XDG_CONFIG_HOME?.trim() || join3(home, ".config");
+var claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join3(home, ".claude");
+var codexHome = process.env.CODEX_HOME?.trim() || join3(home, ".codex");
+var AGENT_REGISTRY = [
+  {
+    slug: "claude",
+    skillsDir: ".claude/skills",
+    globalSkillsDir: join3(claudeHome, "skills"),
+    detectInstalled: () => existsSync(claudeHome)
+  },
+  {
+    slug: "cursor",
+    skillsDir: ".cursor/skills",
+    globalSkillsDir: join3(home, ".cursor", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".cursor"))
+  },
+  {
+    slug: "windsurf",
+    skillsDir: ".windsurf/skills",
+    globalSkillsDir: join3(home, ".codeium", "windsurf", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".codeium", "windsurf"))
+  },
+  {
+    slug: "continue",
+    skillsDir: ".continue/skills",
+    globalSkillsDir: join3(home, ".continue", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".continue"))
+  },
+  {
+    slug: "copilot",
+    skillsDir: ".copilot/skills",
+    globalSkillsDir: join3(home, ".copilot", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".copilot"))
+  },
+  {
+    slug: "gemini",
+    skillsDir: ".gemini/skills",
+    globalSkillsDir: join3(home, ".gemini", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".gemini"))
+  },
+  {
+    slug: "augment",
+    skillsDir: ".augment/rules",
+    globalSkillsDir: join3(home, ".augment", "rules"),
+    detectInstalled: () => existsSync(join3(home, ".augment"))
+  },
+  {
+    slug: "cline",
+    skillsDir: ".cline/skills",
+    globalSkillsDir: join3(home, ".cline", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".cline"))
+  },
+  {
+    slug: "goose",
+    skillsDir: ".goose/skills",
+    globalSkillsDir: join3(configHome, "goose", "skills"),
+    detectInstalled: () => existsSync(join3(configHome, "goose"))
+  },
+  {
+    slug: "junie",
+    skillsDir: ".junie/skills",
+    globalSkillsDir: join3(home, ".junie", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".junie"))
+  },
+  {
+    slug: "kiro",
+    skillsDir: ".kiro/skills",
+    globalSkillsDir: join3(home, ".kiro", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".kiro"))
+  },
+  {
+    slug: "opencode",
+    skillsDir: ".opencode/skills",
+    globalSkillsDir: join3(configHome, "opencode", "skills"),
+    detectInstalled: () => existsSync(join3(configHome, "opencode"))
+  },
+  {
+    slug: "openhands",
+    skillsDir: ".openhands/skills",
+    globalSkillsDir: join3(home, ".openhands", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".openhands"))
+  },
+  {
+    slug: "roo",
+    skillsDir: ".roo/skills",
+    globalSkillsDir: join3(home, ".roo", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".roo"))
+  },
+  {
+    slug: "trae",
+    skillsDir: ".trae/skills",
+    globalSkillsDir: join3(home, ".trae", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".trae"))
+  },
+  {
+    slug: "kode",
+    skillsDir: ".kode/skills",
+    globalSkillsDir: join3(home, ".kode", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".kode"))
+  },
+  {
+    slug: "qwen-code",
+    skillsDir: ".qwen/skills",
+    globalSkillsDir: join3(home, ".qwen", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".qwen"))
+  },
+  {
+    slug: "codex",
+    skillsDir: ".codex/skills",
+    globalSkillsDir: join3(codexHome, "skills"),
+    detectInstalled: () => existsSync(codexHome) || existsSync("/etc/codex")
+  },
+  {
+    slug: "amp",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join3(configHome, "agents", "skills"),
+    detectInstalled: () => existsSync(join3(configHome, "agents"))
+  },
+  {
+    slug: "kilo",
+    skillsDir: ".kilocode/skills",
+    globalSkillsDir: join3(home, ".kilocode", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".kilocode"))
+  },
+  {
+    slug: "pochi",
+    skillsDir: ".pochi/skills",
+    globalSkillsDir: join3(home, ".pochi", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".pochi"))
+  },
+  {
+    slug: "neovate",
+    skillsDir: ".neovate/skills",
+    globalSkillsDir: join3(home, ".neovate", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".neovate"))
+  },
+  {
+    slug: "mux",
+    skillsDir: ".mux/skills",
+    globalSkillsDir: join3(home, ".mux", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".mux"))
+  },
+  {
+    slug: "zencoder",
+    skillsDir: ".zencoder/skills",
+    globalSkillsDir: join3(home, ".zencoder", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".zencoder"))
+  },
+  {
+    slug: "adal",
+    skillsDir: ".adal/skills",
+    globalSkillsDir: join3(home, ".adal", "skills"),
+    detectInstalled: () => existsSync(join3(home, ".adal"))
+  }
+];
+var AGENT_MAP = new Map(AGENT_REGISTRY.map((e) => [e.slug, e]));
+var KNOWN_AGENTS = AGENT_REGISTRY.map((e) => e.slug);
+async function readConfig(cwd = process.cwd(), global = false) {
+  const configPath = global ? join3(KONSTRUCT_DIR, CONFIG_FILENAME) : join3(cwd, CONFIG_FILENAME);
+  if (!await exists(configPath)) return null;
+  const raw = await readFile3(configPath, "utf-8");
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Invalid JSON in ${configPath}: ${e instanceof Error ? e.message : e}`);
+  }
+  validateConfig(config);
+  return config;
+}
+async function writeConfig(config, cwd = process.cwd(), global = false) {
+  const dir = global ? KONSTRUCT_DIR : cwd;
+  if (global) await mkdir(dir, { recursive: true });
+  await writeFile2(join3(dir, CONFIG_FILENAME), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function getAgentSkillDirs(agents, global = false, cwd = process.cwd(), customPath) {
+  if (customPath) return [customPath];
+  const dirs = [];
+  for (const slug of agents) {
+    const entry = AGENT_MAP.get(slug);
+    if (global) {
+      if (entry?.globalSkillsDir) dirs.push(entry.globalSkillsDir);
+    } else {
+      dirs.push(join3(cwd, entry?.skillsDir ?? `.${slug}/skills`));
+    }
+  }
+  return dirs;
+}
+function validateConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Invalid konstruct.config.json: must be a JSON object");
+  }
+  const c = config;
+  if (typeof c.version !== "number") {
+    throw new Error('Invalid konstruct.config.json: "version" must be a number');
+  }
+  if (!Array.isArray(c.agents)) {
+    throw new Error('Invalid konstruct.config.json: "agents" must be an array');
+  }
+}
+
+// src/cli/commands/init.tsx
+import { basename as basename2 } from "path";
+
+// src/cli/components/Banner.tsx
+import { Text, Box } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Banner() {
+  const art = `
+ _  __                 _                   _
+| |/ /___  _ __  ___  | |_  _ __  _   _  ___| |_
+| ' // _ \\| '_ \\/ __| | __|| '__|| | | |/ __| __|
+| . \\ (_) | | | \\__ \\ | |_ | |   | |_| | (__| |_
+|_|\\_\\___/|_| |_|___/  \\__||_|    \\__,_|\\___|\\__|`.trimStart();
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: art }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Package manager for AI agent skills" })
+  ] });
+}
+
+// src/cli/components/StatusMessage.tsx
+import { Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var VARIANTS = {
+  success: { icon: "\u2713", color: "green" },
+  error: { icon: "\u2717", color: "red" },
+  info: { icon: "\u2139", color: "cyan" },
+  warn: { icon: "!", color: "yellow" }
+};
+function StatusMessage({ variant, children }) {
+  const { icon, color } = VARIANTS[variant];
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { color, children: icon }),
+    " ",
+    children
+  ] });
+}
+
+// src/cli/components/MultiSelect.tsx
+import { Text as Text3, Box as Box2, useInput } from "ink";
+import { useState } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function MultiSelect({ prompt, items, onConfirm }) {
+  const [cursor, setCursor] = useState(0);
+  const [selected, setSelected] = useState(/* @__PURE__ */ new Set());
+  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 (input === " ") {
+      setSelected((prev) => {
+        const next = new Set(prev);
+        if (next.has(cursor)) next.delete(cursor);
+        else next.add(cursor);
+        return next;
+      });
+    } else if (key.return) {
+      onConfirm([...selected].sort((a, b) => a - b));
+    }
+  });
+  if (!process.stdin.isTTY) {
+    return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: prompt }),
+      items.map((item, i) => /* @__PURE__ */ jsxs3(Text3, { children: [
+        "  ",
+        i + 1,
+        ". ",
+        item
+      ] }, i))
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: prompt }),
+    items.map((item, i) => {
+      const arrow = i === cursor ? /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "\u203A" }) : /* @__PURE__ */ jsx3(Text3, { children: " " });
+      const box = selected.has(i) ? /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2611" }) : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2610" });
+      const label = i === cursor ? /* @__PURE__ */ jsx3(Text3, { bold: true, children: item }) : /* @__PURE__ */ jsx3(Text3, { children: item });
+      return /* @__PURE__ */ jsxs3(Text3, { children: [
+        "  ",
+        arrow,
+        " ",
+        box,
+        " ",
+        label
+      ] }, i);
+    }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  \u2191\u2193 move  space select  enter confirm" })
+  ] });
+}
+
+// src/cli/prompts.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+var home2 = homedir2();
+var configHome2 = process.env.XDG_CONFIG_HOME?.trim() || join4(home2, ".config");
+var claudeHome2 = process.env.CLAUDE_CONFIG_DIR?.trim() || join4(home2, ".claude");
+var codexHome2 = process.env.CODEX_HOME?.trim() || join4(home2, ".codex");
+var AGENT_DETECTORS = {
+  claude: () => existsSync2(claudeHome2),
+  cursor: () => existsSync2(join4(home2, ".cursor")),
+  windsurf: () => existsSync2(join4(home2, ".codeium", "windsurf")),
+  continue: () => existsSync2(join4(home2, ".continue")),
+  copilot: () => existsSync2(join4(home2, ".copilot")),
+  gemini: () => existsSync2(join4(home2, ".gemini")),
+  augment: () => existsSync2(join4(home2, ".augment")),
+  cline: () => existsSync2(join4(home2, ".cline")),
+  goose: () => existsSync2(join4(configHome2, "goose")),
+  junie: () => existsSync2(join4(home2, ".junie")),
+  kiro: () => existsSync2(join4(home2, ".kiro")),
+  opencode: () => existsSync2(join4(configHome2, "opencode")),
+  openhands: () => existsSync2(join4(home2, ".openhands")),
+  roo: () => existsSync2(join4(home2, ".roo")),
+  trae: () => existsSync2(join4(home2, ".trae")),
+  kode: () => existsSync2(join4(home2, ".kode")),
+  "qwen-code": () => existsSync2(join4(home2, ".qwen")),
+  codex: () => existsSync2(codexHome2) || existsSync2("/etc/codex"),
+  amp: () => existsSync2(join4(configHome2, "agents")),
+  kilo: () => existsSync2(join4(home2, ".kilocode")),
+  pochi: () => existsSync2(join4(home2, ".pochi")),
+  neovate: () => existsSync2(join4(home2, ".neovate")),
+  mux: () => existsSync2(join4(home2, ".mux")),
+  zencoder: () => existsSync2(join4(home2, ".zencoder")),
+  adal: () => existsSync2(join4(home2, ".adal"))
+};
+function detectInstalledAgents() {
+  const installed = /* @__PURE__ */ new Set();
+  for (const slug of KNOWN_AGENTS) {
+    const detect = AGENT_DETECTORS[slug];
+    if (detect?.()) installed.add(slug);
+  }
+  return installed;
+}
+function getAgentLabels() {
+  const installed = detectInstalledAgents();
+  const detected = KNOWN_AGENTS.filter((a) => installed.has(a));
+  const rest = KNOWN_AGENTS.filter((a) => !installed.has(a));
+  const ordered = [...detected, ...rest];
+  const labels = ordered.map((a) => installed.has(a) ? `${a} (detected)` : a);
+  return { ordered, labels };
+}
+
+// src/cli/commands/init.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function InitApp({ options }) {
+  const { exit } = useApp();
+  const [phase, setPhase] = useState2("init");
+  const [messages, setMessages] = useState2([]);
+  const [showAgentPrompt, setShowAgentPrompt] = useState2(false);
+  const [agentLabels, setAgentLabels] = useState2([]);
+  const [agentSlugs, setAgentSlugs] = useState2([]);
+  const [cwd] = useState2(() => options.global ? KONSTRUCT_DIR : process.cwd());
+  const [scope] = useState2(() => options.global ? "global" : "project");
+  useEffect(() => {
+    if (phase === "done") exit();
+  }, [phase, exit]);
+  const [initialized, setInitialized] = useState2(false);
+  if (!initialized) {
+    setInitialized(true);
+    (async () => {
+      const msgs = [];
+      const existingManifest = await readManifest(cwd);
+      if (existingManifest) {
+        msgs.push({ variant: "warn", text: `${scope} skills.json already exists \u2014 skipping.` });
+      } else {
+        await writeManifest(
+          { name: basename2(cwd), version: "1.0.0", skills: {} },
+          cwd
+        );
+        msgs.push({ variant: "success", text: `Created ${scope} skills.json` });
+      }
+      const existingConfig = await readConfig(cwd);
+      if (existingConfig) {
+        msgs.push({ variant: "warn", text: `${scope} konstruct.config.json already exists \u2014 skipping.` });
+        msgs.push({
+          variant: "info",
+          text: options.global ? 'Global configuration created. Use "konstruct add -g <source>" to add global skills.' : 'Run "konstruct add <source>" to add your first skill.'
+        });
+        setMessages(msgs);
+        setPhase("done");
+      } else {
+        msgs.push({
+          variant: "info",
+          text: options.global ? "Which AI agents do you want as global defaults?" : "Which AI agents do you use in this project?"
+        });
+        setMessages(msgs);
+        const { ordered, labels } = getAgentLabels();
+        setAgentSlugs(ordered);
+        setAgentLabels(labels);
+        setShowAgentPrompt(true);
+        setPhase("select-agents");
+      }
+    })();
+  }
+  const onAgentsConfirm = useCallback(async (indices) => {
+    const agents = indices.length === 0 ? ["claude"] : indices.map((i) => agentSlugs[i]);
+    const config = {
+      version: 1,
+      agents,
+      ...options.global && { global: { defaultAgents: agents } }
+    };
+    await writeConfig(config, cwd);
+    setMessages((prev) => [
+      ...prev,
+      { variant: "success", text: `Created ${scope} konstruct.config.json (agents: ${agents.join(", ")})` },
+      {
+        variant: "info",
+        text: options.global ? 'Global configuration created. Use "konstruct add -g <source>" to add global skills.' : 'Run "konstruct add <source>" to add your first skill.'
+      }
+    ]);
+    setShowAgentPrompt(false);
+    setPhase("done");
+  }, [agentSlugs, cwd, scope, options.global]);
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Banner, {}),
+    messages.map((m, i) => /* @__PURE__ */ jsx4(StatusMessage, { variant: m.variant, children: m.text }, i)),
+    showAgentPrompt && /* @__PURE__ */ jsx4(
+      MultiSelect,
+      {
+        prompt: "Select your preferred AI agent(s)",
+        items: agentLabels,
+        onConfirm: onAgentsConfirm
+      }
+    )
+  ] });
+}
+async function initCommand(options = {}) {
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx4(InitApp, { options }));
+  await waitUntilExit();
+}
+
+export {
+  exists,
+  hashDirectory,
+  diffHashes,
+  parseSource,
+  parseSkillEntry,
+  readManifest,
+  addSkillToManifest,
+  removeSkillFromManifest,
+  KONSTRUCT_DIR,
+  AGENT_REGISTRY,
+  readConfig,
+  writeConfig,
+  getAgentSkillDirs,
+  Banner,
+  StatusMessage,
+  MultiSelect,
+  getAgentLabels,
+  initCommand
+};