@claude-collective/cli 0.2.0 → 0.8.0

package/dist/chunk-LVKRVFYR.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli-v2/components/wizard/section-progress.tsx
+init_esm_shims();
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var SectionProgress = ({
+  label,
+  current,
+  index,
+  total,
+  next
+}) => {
+  const isLast = index === total;
+  const rightText = isLast ? "Last step" : `Next: ${next}`;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "row",
+      justifyContent: "space-between",
+      paddingX: 2,
+      marginBottom: 1,
+      children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+            label,
+            ":"
+          ] }),
+          " ",
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: current })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "[",
+            index,
+            "/",
+            total,
+            "]"
+          ] }),
+          " ",
+          /* @__PURE__ */ jsx(Text, { dimColor: isLast, children: rightText })
+        ] })
+      ]
+    }
+  );
+};
+
+export {
+  SectionProgress
+};
+//# sourceMappingURL=chunk-LVKRVFYR.js.map

package/dist/chunk-LVKRVFYR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli-v2/components/wizard/section-progress.tsx"],"sourcesContent":["import React from \"react\";\nimport { Box, Text } from \"ink\";\n\nexport interface SectionProgressProps {\n  /** Section label (e.g., \"Domain\" or \"Skill\") */\n  label: string;\n  /** Current item name (e.g., \"Web\" or \"react\") */\n  current: string;\n  /** 1-based index */\n  index: number;\n  /** Total count */\n  total: number;\n  /** Next item name, or undefined if last */\n  next?: string;\n}\n\nexport const SectionProgress: React.FC<SectionProgressProps> = ({\n  label,\n  current,\n  index,\n  total,\n  next,\n}) => {\n  const isLast = index === total;\n  const rightText = isLast ? \"Last step\" : `Next: ${next}`;\n\n  return (\n    <Box\n      flexDirection=\"row\"\n      justifyContent=\"space-between\"\n      paddingX={2}\n      marginBottom={1}\n    >\n      <Text>\n        <Text bold>{label}:</Text> <Text color=\"cyan\">{current}</Text>\n      </Text>\n      <Text>\n        <Text dimColor>\n          [{index}/{total}]\n        </Text>{\" \"}\n        <Text dimColor={isLast}>{rightText}</Text>\n      </Text>\n    </Box>\n  );\n};\n"],"mappings":";;;;;;AAAA;AACA,SAAS,KAAK,YAAY;AAiClB,SAA2B,KAA3B;AAlBD,IAAM,kBAAkD,CAAC;AAAA,EAC9D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAM;AACJ,QAAM,SAAS,UAAU;AACzB,QAAM,YAAY,SAAS,cAAc,SAAS,IAAI;AAEtD,SACE;AAAA,IAAC;AAAA;AAAA,MACC,eAAc;AAAA,MACd,gBAAe;AAAA,MACf,UAAU;AAAA,MACV,cAAc;AAAA,MAEd;AAAA,6BAAC,QACC;AAAA,+BAAC,QAAK,MAAI,MAAE;AAAA;AAAA,YAAM;AAAA,aAAC;AAAA,UAAO;AAAA,UAAC,oBAAC,QAAK,OAAM,QAAQ,mBAAQ;AAAA,WACzD;AAAA,QACA,qBAAC,QACC;AAAA,+BAAC,QAAK,UAAQ,MAAC;AAAA;AAAA,YACX;AAAA,YAAM;AAAA,YAAE;AAAA,YAAM;AAAA,aAClB;AAAA,UAAQ;AAAA,UACR,oBAAC,QAAK,UAAU,QAAS,qBAAU;AAAA,WACrC;AAAA;AAAA;AAAA,EACF;AAEJ;","names":[]}

package/dist/chunk-M7YCPFIX.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli-v2/utils/exec.ts
+init_esm_shims();
+import { spawn } from "child_process";
+async function execCommand(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options?.cwd,
+      env: { ...process.env, ...options?.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 1
+      });
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function claudePluginInstall(pluginPath, scope, projectDir) {
+  const args = ["plugin", "install", pluginPath, "--scope", scope];
+  const result = await execCommand("claude", args, { cwd: projectDir });
+  if (result.exitCode !== 0) {
+    const errorMessage = result.stderr || result.stdout || "Unknown error";
+    throw new Error(`Plugin installation failed: ${errorMessage.trim()}`);
+  }
+}
+async function isClaudeCLIAvailable() {
+  try {
+    const result = await execCommand("claude", ["--version"], {});
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function claudePluginMarketplaceList() {
+  try {
+    const result = await execCommand(
+      "claude",
+      ["plugin", "marketplace", "list", "--json"],
+      {}
+    );
+    if (result.exitCode !== 0) {
+      return [];
+    }
+    return JSON.parse(result.stdout);
+  } catch {
+    return [];
+  }
+}
+async function claudePluginMarketplaceExists(name) {
+  const marketplaces = await claudePluginMarketplaceList();
+  return marketplaces.some((m) => m.name === name);
+}
+async function claudePluginMarketplaceAdd(githubRepo, name) {
+  const args = ["plugin", "marketplace", "add", githubRepo, "--name", name];
+  let result;
+  try {
+    result = await execCommand("claude", args, {});
+  } catch (err) {
+    throw new Error(
+      `Failed to add marketplace: ${err instanceof Error ? err.message : "Unknown error"}`
+    );
+  }
+  if (result.exitCode !== 0) {
+    const errorMessage = result.stderr || result.stdout || "Unknown error";
+    if (errorMessage.includes("already installed")) {
+      return;
+    }
+    throw new Error(`Failed to add marketplace: ${errorMessage.trim()}`);
+  }
+}
+async function claudePluginUninstall(pluginName, scope, projectDir) {
+  const args = ["plugin", "uninstall", pluginName, "--scope", scope];
+  const result = await execCommand("claude", args, { cwd: projectDir });
+  if (result.exitCode !== 0) {
+    const errorMessage = result.stderr || result.stdout || "Unknown error";
+    if (errorMessage.includes("not installed") || errorMessage.includes("not found")) {
+      return;
+    }
+    throw new Error(`Plugin uninstall failed: ${errorMessage.trim()}`);
+  }
+}
+
+export {
+  claudePluginInstall,
+  isClaudeCLIAvailable,
+  claudePluginMarketplaceExists,
+  claudePluginMarketplaceAdd,
+  claudePluginUninstall
+};
+//# sourceMappingURL=chunk-M7YCPFIX.js.map

package/dist/chunk-M7YCPFIX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli-v2/utils/exec.ts"],"sourcesContent":["import { spawn } from \"child_process\";\n\nexport interface ExecResult {\n  stdout: string;\n  stderr: string;\n  exitCode: number;\n}\n\n/**\n * Execute a command and return the result\n */\nexport async function execCommand(\n  command: string,\n  args: string[],\n  options?: { cwd?: string; env?: NodeJS.ProcessEnv },\n): Promise<ExecResult> {\n  return new Promise((resolve, reject) => {\n    const proc = spawn(command, args, {\n      cwd: options?.cwd,\n      env: { ...process.env, ...options?.env },\n      stdio: [\"ignore\", \"pipe\", \"pipe\"],\n    });\n\n    let stdout = \"\";\n    let stderr = \"\";\n\n    proc.stdout.on(\"data\", (data) => {\n      stdout += data.toString();\n    });\n\n    proc.stderr.on(\"data\", (data) => {\n      stderr += data.toString();\n    });\n\n    proc.on(\"close\", (code) => {\n      resolve({\n        stdout,\n        stderr,\n        exitCode: code ?? 1,\n      });\n    });\n\n    proc.on(\"error\", (err) => {\n      reject(err);\n    });\n  });\n}\n\n/**\n * Install a plugin using the native claude CLI\n */\nexport async function claudePluginInstall(\n  pluginPath: string,\n  scope: \"project\" | \"user\",\n  projectDir: string,\n): Promise<void> {\n  const args = [\"plugin\", \"install\", pluginPath, \"--scope\", scope];\n  const result = await execCommand(\"claude\", args, { cwd: projectDir });\n\n  if (result.exitCode !== 0) {\n    const errorMessage = result.stderr || result.stdout || \"Unknown error\";\n    throw new Error(`Plugin installation failed: ${errorMessage.trim()}`);\n  }\n}\n\n/**\n * Check if the claude CLI is available\n */\nexport async function isClaudeCLIAvailable(): Promise<boolean> {\n  try {\n    const result = await execCommand(\"claude\", [\"--version\"], {});\n    return result.exitCode === 0;\n  } catch {\n    return false;\n  }\n}\n\nexport interface MarketplaceInfo {\n  name: string;\n  source: string;\n  repo?: string;\n  path?: string;\n}\n\n/**\n * List configured marketplaces in Claude Code\n */\nexport async function claudePluginMarketplaceList(): Promise<\n  MarketplaceInfo[]\n> {\n  try {\n    const result = await execCommand(\n      \"claude\",\n      [\"plugin\", \"marketplace\", \"list\", \"--json\"],\n      {},\n    );\n\n    if (result.exitCode !== 0) {\n      return [];\n    }\n\n    return JSON.parse(result.stdout);\n  } catch {\n    // Returns empty array if claude CLI is not available or parsing fails\n    return [];\n  }\n}\n\n/**\n * Check if a marketplace with the given name exists\n */\nexport async function claudePluginMarketplaceExists(\n  name: string,\n): Promise<boolean> {\n  const marketplaces = await claudePluginMarketplaceList();\n  return marketplaces.some((m) => m.name === name);\n}\n\n/**\n * Add a marketplace to Claude Code from a GitHub repository\n */\nexport async function claudePluginMarketplaceAdd(\n  githubRepo: string,\n  name: string,\n): Promise<void> {\n  const args = [\"plugin\", \"marketplace\", \"add\", githubRepo, \"--name\", name];\n  let result;\n  try {\n    result = await execCommand(\"claude\", args, {});\n  } catch (err) {\n    throw new Error(\n      `Failed to add marketplace: ${err instanceof Error ? err.message : \"Unknown error\"}`,\n    );\n  }\n\n  if (result.exitCode !== 0) {\n    const errorMessage = result.stderr || result.stdout || \"Unknown error\";\n    if (errorMessage.includes(\"already installed\")) {\n      return;\n    }\n    throw new Error(`Failed to add marketplace: ${errorMessage.trim()}`);\n  }\n}\n\n/**\n * Uninstall a plugin using the native claude CLI\n */\nexport async function claudePluginUninstall(\n  pluginName: string,\n  scope: \"project\" | \"user\",\n  projectDir: string,\n): Promise<void> {\n  const args = [\"plugin\", \"uninstall\", pluginName, \"--scope\", scope];\n  const result = await execCommand(\"claude\", args, { cwd: projectDir });\n\n  if (result.exitCode !== 0) {\n    const errorMessage = result.stderr || result.stdout || \"Unknown error\";\n    // Ignore \"not installed\" errors - plugin may already be removed\n    if (\n      errorMessage.includes(\"not installed\") ||\n      errorMessage.includes(\"not found\")\n    ) {\n      return;\n    }\n    throw new Error(`Plugin uninstall failed: ${errorMessage.trim()}`);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-MJSFR562.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import {
+  fileExists,
+  glob,
+  readFile
+} from "./chunk-MMDXNZPF.js";
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli-v2/lib/versioning.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import path from "path";
+import { stringify as stringifyYaml, parse as parseYaml } from "yaml";
+var HASH_PREFIX_LENGTH = 7;
+var HASHABLE_FILES = ["SKILL.md", "reference.md"];
+var HASHABLE_DIRS = ["examples", "scripts"];
+function hashString(content) {
+  const hash = createHash("sha256");
+  hash.update(content);
+  return hash.digest("hex").slice(0, HASH_PREFIX_LENGTH);
+}
+async function hashFile(filePath) {
+  const content = await readFile(filePath);
+  return hashString(content);
+}
+async function hashSkillFolder(skillPath) {
+  const contents = [];
+  for (const fileName of HASHABLE_FILES) {
+    const filePath = path.join(skillPath, fileName);
+    if (await fileExists(filePath)) {
+      const content = await readFile(filePath);
+      contents.push(`${fileName}:${content}`);
+    }
+  }
+  for (const dirName of HASHABLE_DIRS) {
+    const dirPath = path.join(skillPath, dirName);
+    if (await fileExists(dirPath)) {
+      const files = await glob("**/*", dirPath);
+      for (const file of files.sort()) {
+        const filePath = path.join(dirPath, file);
+        const content = await readFile(filePath);
+        contents.push(`${dirName}/${file}:${content}`);
+      }
+    }
+  }
+  const combined = contents.join("\n---\n");
+  return hashString(combined);
+}
+
+export {
+  hashString,
+  hashFile,
+  hashSkillFolder
+};
+//# sourceMappingURL=chunk-MJSFR562.js.map

package/dist/chunk-MJSFR562.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli-v2/lib/versioning.ts"],"sourcesContent":["import { createHash } from \"crypto\";\nimport path from \"path\";\nimport { stringify as stringifyYaml, parse as parseYaml } from \"yaml\";\nimport { readFile, writeFile, glob, fileExists } from \"../utils/fs\";\nimport { verbose } from \"../utils/logger\";\n\nconst HASH_PREFIX_LENGTH = 7;\n\nconst METADATA_FILE_NAME = \"metadata.yaml\";\n\nconst HASHABLE_FILES = [\"SKILL.md\", \"reference.md\"];\n\nconst HASHABLE_DIRS = [\"examples\", \"scripts\"];\n\ninterface VersionedMetadata {\n  version: number;\n  content_hash?: string;\n  updated?: string;\n  [key: string]: unknown;\n}\n\nexport interface VersionCheckResult {\n  skillPath: string;\n  previousVersion: number;\n  newVersion: number;\n  previousHash: string | undefined;\n  newHash: string;\n  changed: boolean;\n}\n\nexport function getCurrentDate(): string {\n  return new Date().toISOString().split(\"T\")[0];\n}\n\nexport function hashString(content: string): string {\n  const hash = createHash(\"sha256\");\n  hash.update(content);\n  return hash.digest(\"hex\").slice(0, HASH_PREFIX_LENGTH);\n}\n\nexport async function hashFile(filePath: string): Promise<string> {\n  const content = await readFile(filePath);\n  return hashString(content);\n}\n\nexport async function hashSkillFolder(skillPath: string): Promise<string> {\n  const contents: string[] = [];\n\n  for (const fileName of HASHABLE_FILES) {\n    const filePath = path.join(skillPath, fileName);\n    if (await fileExists(filePath)) {\n      const content = await readFile(filePath);\n      contents.push(`${fileName}:${content}`);\n    }\n  }\n\n  for (const dirName of HASHABLE_DIRS) {\n    const dirPath = path.join(skillPath, dirName);\n    if (await fileExists(dirPath)) {\n      const files = await glob(\"**/*\", dirPath);\n      for (const file of files.sort()) {\n        const filePath = path.join(dirPath, file);\n        const content = await readFile(filePath);\n        contents.push(`${dirName}/${file}:${content}`);\n      }\n    }\n  }\n\n  const combined = contents.join(\"\\n---\\n\");\n  return hashString(combined);\n}\n\nasync function readMetadata(\n  skillPath: string,\n): Promise<{ metadata: VersionedMetadata; schemaComment: string }> {\n  const metadataPath = path.join(skillPath, METADATA_FILE_NAME);\n  const rawContent = await readFile(metadataPath);\n\n  const lines = rawContent.split(\"\\n\");\n  let schemaComment = \"\";\n  let yamlContent = rawContent;\n\n  if (lines[0]?.startsWith(\"# yaml-language-server:\")) {\n    schemaComment = lines[0] + \"\\n\";\n    yamlContent = lines.slice(1).join(\"\\n\");\n  }\n\n  const metadata = parseYaml(yamlContent) as VersionedMetadata;\n  return { metadata, schemaComment };\n}\n\nasync function writeMetadata(\n  skillPath: string,\n  metadata: VersionedMetadata,\n  schemaComment: string,\n): Promise<void> {\n  const metadataPath = path.join(skillPath, METADATA_FILE_NAME);\n  const yamlContent = stringifyYaml(metadata, { lineWidth: 0 });\n  await writeFile(metadataPath, schemaComment + yamlContent);\n}\n\nexport async function versionSkill(\n  skillPath: string,\n): Promise<VersionCheckResult> {\n  const newHash = await hashSkillFolder(skillPath);\n\n  const { metadata, schemaComment } = await readMetadata(skillPath);\n  const previousVersion = metadata.version;\n  const previousHash = metadata.content_hash;\n\n  const changed = previousHash !== newHash;\n\n  if (changed) {\n    metadata.version = previousVersion + 1;\n    metadata.content_hash = newHash;\n    metadata.updated = getCurrentDate();\n\n    await writeMetadata(skillPath, metadata, schemaComment);\n\n    verbose(\n      `  Version bumped: ${skillPath} (v${previousVersion} -> v${metadata.version})`,\n    );\n  }\n\n  return {\n    skillPath,\n    previousVersion,\n    newVersion: changed ? previousVersion + 1 : previousVersion,\n    previousHash,\n    newHash,\n    changed,\n  };\n}\n\nexport async function versionAllSkills(\n  skillsDir: string,\n): Promise<VersionCheckResult[]> {\n  const results: VersionCheckResult[] = [];\n\n  const metadataFiles = await glob(\"**/metadata.yaml\", skillsDir);\n\n  for (const metadataFile of metadataFiles) {\n    const skillPath = path.join(skillsDir, path.dirname(metadataFile));\n\n    try {\n      const result = await versionSkill(skillPath);\n      results.push(result);\n    } catch (error) {\n      console.warn(\n        `  Warning: Failed to version skill at ${skillPath}: ${error}`,\n      );\n    }\n  }\n\n  return results;\n}\n\nexport function printVersionResults(results: VersionCheckResult[]): void {\n  const changed = results.filter((r) => r.changed);\n  const unchanged = results.filter((r) => !r.changed);\n\n  if (changed.length > 0) {\n    console.log(`\\n  Version Updates:`);\n    for (const result of changed) {\n      const skillName = path.basename(result.skillPath);\n      console.log(\n        `    ✓ ${skillName}: v${result.previousVersion} -> v${result.newVersion}`,\n      );\n    }\n  }\n\n  console.log(\n    `\\n  Summary: ${changed.length} updated, ${unchanged.length} unchanged`,\n  );\n}\n"],"mappings":";;;;;;;;;;;AAAA;AAAA,SAAS,kBAAkB;AAC3B,OAAO,UAAU;AACjB,SAAS,aAAa,eAAe,SAAS,iBAAiB;AAI/D,IAAM,qBAAqB;AAI3B,IAAM,iBAAiB,CAAC,YAAY,cAAc;AAElD,IAAM,gBAAgB,CAAC,YAAY,SAAS;AAsBrC,SAAS,WAAW,SAAyB;AAClD,QAAM,OAAO,WAAW,QAAQ;AAChC,OAAK,OAAO,OAAO;AACnB,SAAO,KAAK,OAAO,KAAK,EAAE,MAAM,GAAG,kBAAkB;AACvD;AAEA,eAAsB,SAAS,UAAmC;AAChE,QAAM,UAAU,MAAM,SAAS,QAAQ;AACvC,SAAO,WAAW,OAAO;AAC3B;AAEA,eAAsB,gBAAgB,WAAoC;AACxE,QAAM,WAAqB,CAAC;AAE5B,aAAW,YAAY,gBAAgB;AACrC,UAAM,WAAW,KAAK,KAAK,WAAW,QAAQ;AAC9C,QAAI,MAAM,WAAW,QAAQ,GAAG;AAC9B,YAAM,UAAU,MAAM,SAAS,QAAQ;AACvC,eAAS,KAAK,GAAG,QAAQ,IAAI,OAAO,EAAE;AAAA,IACxC;AAAA,EACF;AAEA,aAAW,WAAW,eAAe;AACnC,UAAM,UAAU,KAAK,KAAK,WAAW,OAAO;AAC5C,QAAI,MAAM,WAAW,OAAO,GAAG;AAC7B,YAAM,QAAQ,MAAM,KAAK,QAAQ,OAAO;AACxC,iBAAW,QAAQ,MAAM,KAAK,GAAG;AAC/B,cAAM,WAAW,KAAK,KAAK,SAAS,IAAI;AACxC,cAAM,UAAU,MAAM,SAAS,QAAQ;AACvC,iBAAS,KAAK,GAAG,OAAO,IAAI,IAAI,IAAI,OAAO,EAAE;AAAA,MAC/C;AAAA,IACF;AAAA,EACF;AAEA,QAAM,WAAW,SAAS,KAAK,SAAS;AACxC,SAAO,WAAW,QAAQ;AAC5B;","names":[]}

package/dist/chunk-MMDXNZPF.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli-v2/utils/fs.ts
+init_esm_shims();
+import fs from "fs-extra";
+import fg from "fast-glob";
+import path from "path";
+async function readFile(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+async function readFileOptional(filePath, fallback = "") {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return fallback;
+  }
+}
+async function fileExists(filePath) {
+  return fs.pathExists(filePath);
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function listDirectories(dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function glob(pattern, cwd) {
+  return fg(pattern, { cwd, onlyFiles: true });
+}
+async function writeFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function ensureDir(dirPath) {
+  await fs.ensureDir(dirPath);
+}
+async function remove(filePath) {
+  await fs.remove(filePath);
+}
+async function copy(src, dest) {
+  await fs.copy(src, dest);
+}
+
+export {
+  readFile,
+  readFileOptional,
+  fileExists,
+  directoryExists,
+  listDirectories,
+  glob,
+  writeFile,
+  ensureDir,
+  remove,
+  copy
+};
+//# sourceMappingURL=chunk-MMDXNZPF.js.map

package/dist/chunk-MMDXNZPF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli-v2/utils/fs.ts"],"sourcesContent":["import fs from \"fs-extra\";\nimport fg from \"fast-glob\";\nimport path from \"path\";\n\nexport async function readFile(filePath: string): Promise<string> {\n  return fs.readFile(filePath, \"utf-8\");\n}\n\nexport async function readFileOptional(\n  filePath: string,\n  fallback = \"\",\n): Promise<string> {\n  try {\n    return await fs.readFile(filePath, \"utf-8\");\n  } catch {\n    return fallback;\n  }\n}\n\nexport async function fileExists(filePath: string): Promise<boolean> {\n  return fs.pathExists(filePath);\n}\n\nexport async function directoryExists(dirPath: string): Promise<boolean> {\n  try {\n    const stat = await fs.stat(dirPath);\n    return stat.isDirectory();\n  } catch {\n    return false;\n  }\n}\n\nexport async function listDirectories(dirPath: string): Promise<string[]> {\n  try {\n    const entries = await fs.readdir(dirPath, { withFileTypes: true });\n    return entries.filter((e) => e.isDirectory()).map((e) => e.name);\n  } catch {\n    return [];\n  }\n}\n\nexport async function glob(pattern: string, cwd: string): Promise<string[]> {\n  return fg(pattern, { cwd, onlyFiles: true });\n}\n\nexport async function writeFile(\n  filePath: string,\n  content: string,\n): Promise<void> {\n  await fs.ensureDir(path.dirname(filePath));\n  await fs.writeFile(filePath, content, \"utf-8\");\n}\n\nexport async function ensureDir(dirPath: string): Promise<void> {\n  await fs.ensureDir(dirPath);\n}\n\nexport async function remove(filePath: string): Promise<void> {\n  await fs.remove(filePath);\n}\n\nexport async function copy(src: string, dest: string): Promise<void> {\n  await fs.copy(src, dest);\n}\n"],"mappings":";;;;;;AAAA;AAAA,OAAO,QAAQ;AACf,OAAO,QAAQ;AACf,OAAO,UAAU;AAEjB,eAAsB,SAAS,UAAmC;AAChE,SAAO,GAAG,SAAS,UAAU,OAAO;AACtC;AAEA,eAAsB,iBACpB,UACA,WAAW,IACM;AACjB,MAAI;AACF,WAAO,MAAM,GAAG,SAAS,UAAU,OAAO;AAAA,EAC5C,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,eAAsB,WAAW,UAAoC;AACnE,SAAO,GAAG,WAAW,QAAQ;AAC/B;AAEA,eAAsB,gBAAgB,SAAmC;AACvE,MAAI;AACF,UAAM,OAAO,MAAM,GAAG,KAAK,OAAO;AAClC,WAAO,KAAK,YAAY;AAAA,EAC1B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,eAAsB,gBAAgB,SAAoC;AACxE,MAAI;AACF,UAAM,UAAU,MAAM,GAAG,QAAQ,SAAS,EAAE,eAAe,KAAK,CAAC;AACjE,WAAO,QAAQ,OAAO,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,EACjE,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,eAAsB,KAAK,SAAiB,KAAgC;AAC1E,SAAO,GAAG,SAAS,EAAE,KAAK,WAAW,KAAK,CAAC;AAC7C;AAEA,eAAsB,UACpB,UACA,SACe;AACf,QAAM,GAAG,UAAU,KAAK,QAAQ,QAAQ,CAAC;AACzC,QAAM,GAAG,UAAU,UAAU,SAAS,OAAO;AAC/C;AAEA,eAAsB,UAAU,SAAgC;AAC9D,QAAM,GAAG,UAAU,OAAO;AAC5B;AAEA,eAAsB,OAAO,UAAiC;AAC5D,QAAM,GAAG,OAAO,QAAQ;AAC1B;AAEA,eAAsB,KAAK,KAAa,MAA6B;AACnE,QAAM,GAAG,KAAK,KAAK,IAAI;AACzB;","names":[]}

package/dist/chunk-MYAVQ23U.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+import {
+  verbose
+} from "./chunk-TOPAIL5W.js";
+import {
+  fileExists,
+  readFile
+} from "./chunk-MMDXNZPF.js";
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli-v2/lib/project-config.ts
+init_esm_shims();
+import path from "path";
+import { parse as parseYaml } from "yaml";
+var CONFIG_PATH = ".claude/config.yaml";
+async function loadProjectConfig(projectDir) {
+  const configPath = path.join(projectDir, CONFIG_PATH);
+  if (!await fileExists(configPath)) {
+    verbose(`Project config not found at ${configPath}`);
+    return null;
+  }
+  try {
+    const content = await readFile(configPath);
+    const parsed = parseYaml(content);
+    if (!parsed || typeof parsed !== "object") {
+      verbose(`Invalid project config structure at ${configPath}`);
+      return null;
+    }
+    const isLegacy = isLegacyStackConfig(parsed);
+    if (isLegacy) {
+      verbose(`Detected legacy StackConfig format at ${configPath}`);
+      const normalized = normalizeStackConfig(parsed);
+      return {
+        config: normalized,
+        configPath,
+        isLegacy: true
+      };
+    }
+    verbose(`Loaded project config from ${configPath}`);
+    return {
+      config: parsed,
+      configPath,
+      isLegacy: false
+    };
+  } catch (error) {
+    verbose(`Failed to parse project config: ${error}`);
+    return null;
+  }
+}
+function isLegacyStackConfig(config) {
+  if (!config || typeof config !== "object") return false;
+  const obj = config;
+  if (typeof obj.version === "string" && obj.version.includes(".")) {
+    return true;
+  }
+  if (obj.id !== void 0 || obj.created !== void 0 || obj.updated !== void 0) {
+    return true;
+  }
+  return false;
+}
+function normalizeStackConfig(stackConfig) {
+  const config = {
+    name: stackConfig.name,
+    agents: stackConfig.agents
+  };
+  if (stackConfig.description) {
+    config.description = stackConfig.description;
+  }
+  if (stackConfig.skills && stackConfig.skills.length > 0) {
+    config.skills = stackConfig.skills;
+  }
+  if (stackConfig.agent_skills) {
+    config.agent_skills = stackConfig.agent_skills;
+  }
+  if (stackConfig.hooks) {
+    config.hooks = stackConfig.hooks;
+  }
+  if (stackConfig.author) {
+    config.author = stackConfig.author;
+  }
+  if (stackConfig.framework) {
+    config.framework = stackConfig.framework;
+  }
+  if (stackConfig.philosophy) {
+    config.philosophy = stackConfig.philosophy;
+  }
+  if (stackConfig.principles && stackConfig.principles.length > 0) {
+    config.principles = stackConfig.principles;
+  }
+  if (stackConfig.tags && stackConfig.tags.length > 0) {
+    config.tags = stackConfig.tags;
+  }
+  return config;
+}
+function validateProjectConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (!config || typeof config !== "object") {
+    return { valid: false, errors: ["Config must be an object"], warnings: [] };
+  }
+  const c = config;
+  if (!c.name || typeof c.name !== "string") {
+    errors.push("name is required and must be a string");
+  }
+  if (!c.agents || !Array.isArray(c.agents)) {
+    errors.push("agents is required and must be an array");
+  } else {
+    for (const agent of c.agents) {
+      if (typeof agent !== "string") {
+        errors.push(`agents must contain strings, found: ${typeof agent}`);
+      }
+    }
+  }
+  if (c.version !== void 0 && c.version !== "1") {
+    errors.push('version must be "1" (or omitted for default)');
+  }
+  if (c.skills !== void 0) {
+    if (!Array.isArray(c.skills)) {
+      errors.push("skills must be an array");
+    } else {
+      for (const skill of c.skills) {
+        const skillError = validateSkillEntry(skill);
+        if (skillError) {
+          errors.push(skillError);
+        }
+      }
+    }
+  }
+  if (c.agent_skills !== void 0) {
+    if (typeof c.agent_skills !== "object" || c.agent_skills === null) {
+      errors.push("agent_skills must be an object");
+    } else {
+      for (const [agentName, agentSkills] of Object.entries(c.agent_skills)) {
+        const agentSkillsError = validateAgentSkillConfig(
+          agentName,
+          agentSkills
+        );
+        if (agentSkillsError) {
+          errors.push(agentSkillsError);
+        }
+      }
+    }
+  }
+  if (c.preload_patterns !== void 0) {
+    if (typeof c.preload_patterns !== "object" || c.preload_patterns === null) {
+      errors.push("preload_patterns must be an object");
+    } else {
+      for (const [agentName, patterns] of Object.entries(c.preload_patterns)) {
+        if (!Array.isArray(patterns)) {
+          errors.push(
+            `preload_patterns.${agentName} must be an array of strings`
+          );
+        } else {
+          for (const pattern of patterns) {
+            if (typeof pattern !== "string") {
+              errors.push(
+                `preload_patterns.${agentName} must contain only strings`
+              );
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (c.custom_agents !== void 0) {
+    const customAgentsErrors = validateCustomAgents(c.custom_agents, c.agents);
+    errors.push(...customAgentsErrors);
+  }
+  if (c.id !== void 0) {
+    warnings.push("id field is deprecated in project config");
+  }
+  if (c.created !== void 0) {
+    warnings.push("created field is deprecated in project config");
+  }
+  if (c.updated !== void 0) {
+    warnings.push("updated field is deprecated in project config");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+var MAX_CUSTOM_AGENTS = 20;
+var VALID_MODELS = ["sonnet", "opus", "haiku", "inherit"];
+var VALID_PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "dontAsk",
+  "bypassPermissions",
+  "plan",
+  "delegate"
+];
+function validateCustomAgents(customAgents, agents) {
+  const errors = [];
+  if (typeof customAgents !== "object" || customAgents === null) {
+    errors.push("custom_agents must be an object");
+    return errors;
+  }
+  const customAgentEntries = Object.entries(customAgents);
+  if (customAgentEntries.length > MAX_CUSTOM_AGENTS) {
+    errors.push(
+      `custom_agents cannot exceed ${MAX_CUSTOM_AGENTS} agents (found ${customAgentEntries.length})`
+    );
+  }
+  const customAgentNames = new Set(customAgentEntries.map(([name]) => name));
+  for (const [agentName, agentConfig] of customAgentEntries) {
+    const agentErrors = validateCustomAgentConfig(
+      agentName,
+      agentConfig,
+      customAgentNames
+    );
+    errors.push(...agentErrors);
+  }
+  return errors;
+}
+function validateCustomAgentConfig(agentName, config, customAgentNames) {
+  const errors = [];
+  const prefix = `custom_agents.${agentName}`;
+  if (typeof config !== "object" || config === null) {
+    errors.push(`${prefix} must be an object`);
+    return errors;
+  }
+  const c = config;
+  if (!c.title || typeof c.title !== "string") {
+    errors.push(`${prefix}.title is required and must be a string`);
+  }
+  if (!c.description || typeof c.description !== "string") {
+    errors.push(`${prefix}.description is required and must be a string`);
+  }
+  if (c.extends !== void 0) {
+    if (typeof c.extends !== "string") {
+      errors.push(`${prefix}.extends must be a string`);
+    } else if (customAgentNames.has(c.extends)) {
+      errors.push(
+        `${prefix}.extends cannot reference another custom agent "${c.extends}"`
+      );
+    }
+  }
+  if (c.model !== void 0) {
+    if (typeof c.model !== "string" || !VALID_MODELS.includes(c.model)) {
+      errors.push(`${prefix}.model must be one of: ${VALID_MODELS.join(", ")}`);
+    }
+  }
+  if (c.tools !== void 0) {
+    if (!Array.isArray(c.tools)) {
+      errors.push(`${prefix}.tools must be an array`);
+    } else {
+      for (const tool of c.tools) {
+        if (typeof tool !== "string") {
+          errors.push(`${prefix}.tools must contain only strings`);
+          break;
+        }
+      }
+    }
+  }
+  if (c.disallowed_tools !== void 0) {
+    if (!Array.isArray(c.disallowed_tools)) {
+      errors.push(`${prefix}.disallowed_tools must be an array`);
+    } else {
+      for (const tool of c.disallowed_tools) {
+        if (typeof tool !== "string") {
+          errors.push(`${prefix}.disallowed_tools must contain only strings`);
+          break;
+        }
+      }
+    }
+  }
+  if (c.permission_mode !== void 0) {
+    if (typeof c.permission_mode !== "string" || !VALID_PERMISSION_MODES.includes(c.permission_mode)) {
+      errors.push(
+        `${prefix}.permission_mode must be one of: ${VALID_PERMISSION_MODES.join(", ")}`
+      );
+    }
+  }
+  if (c.skills !== void 0) {
+    if (!Array.isArray(c.skills)) {
+      errors.push(`${prefix}.skills must be an array`);
+    } else {
+      for (const skill of c.skills) {
+        const skillError = validateSkillEntry(skill);
+        if (skillError) {
+          errors.push(`${prefix}.skills: ${skillError}`);
+        }
+      }
+    }
+  }
+  if (c.hooks !== void 0) {
+    if (typeof c.hooks !== "object" || c.hooks === null) {
+      errors.push(`${prefix}.hooks must be an object`);
+    }
+  }
+  return errors;
+}
+function validateSkillEntry(skill) {
+  if (typeof skill === "string") {
+    return null;
+  }
+  if (typeof skill !== "object" || skill === null) {
+    return "skills must be strings or objects";
+  }
+  const s = skill;
+  if (!s.id || typeof s.id !== "string") {
+    return "skill object must have an id string";
+  }
+  if (s.local === true && !s.path) {
+    return `local skill "${s.id}" must have a path`;
+  }
+  if (s.preloaded !== void 0 && typeof s.preloaded !== "boolean") {
+    return `skill "${s.id}" preloaded must be a boolean`;
+  }
+  if (s.local !== void 0 && typeof s.local !== "boolean") {
+    return `skill "${s.id}" local must be a boolean`;
+  }
+  if (s.path !== void 0 && typeof s.path !== "string") {
+    return `skill "${s.id}" path must be a string`;
+  }
+  return null;
+}
+function validateAgentSkillConfig(agentName, agentSkills) {
+  if (Array.isArray(agentSkills)) {
+    for (const skill of agentSkills) {
+      const skillError = validateSkillEntry(skill);
+      if (skillError) {
+        return `agent_skills.${agentName}: ${skillError}`;
+      }
+    }
+    return null;
+  }
+  if (typeof agentSkills === "object" && agentSkills !== null) {
+    for (const [category, skills] of Object.entries(agentSkills)) {
+      if (!Array.isArray(skills)) {
+        return `agent_skills.${agentName}.${category} must be an array`;
+      }
+      for (const skill of skills) {
+        const skillError = validateSkillEntry(skill);
+        if (skillError) {
+          return `agent_skills.${agentName}.${category}: ${skillError}`;
+        }
+      }
+    }
+    return null;
+  }
+  return `agent_skills.${agentName} must be an array or object`;
+}
+
+export {
+  loadProjectConfig,
+  isLegacyStackConfig,
+  normalizeStackConfig,
+  validateProjectConfig
+};
+//# sourceMappingURL=chunk-MYAVQ23U.js.map