@claude-collective/cli 0.2.0 → 0.8.0

package/dist/chunk-QGGSLMO3.js

@@ -0,0 +1,607 @@
+#!/usr/bin/env node
+import {
+  DIRS
+} from "./chunk-A3J6IAXK.js";
+import {
+  verbose
+} from "./chunk-TOPAIL5W.js";
+import {
+  directoryExists,
+  fileExists,
+  glob,
+  readFile
+} from "./chunk-MMDXNZPF.js";
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli-v2/lib/loader.ts
+init_esm_shims();
+import { parse as parseYaml } from "yaml";
+import path from "path";
+var FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---/;
+function parseFrontmatter(content) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) return null;
+  const yamlContent = match[1];
+  const frontmatter = parseYaml(yamlContent);
+  if (!frontmatter.name || !frontmatter.description) return null;
+  return frontmatter;
+}
+function extractDisplayName(skillId) {
+  const withoutCategory = skillId.split("/").pop() || skillId;
+  const withoutAuthor = withoutCategory.replace(/\s*\(@\w+\)$/, "").trim();
+  return withoutAuthor.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+async function loadAllAgents(projectRoot) {
+  const agents = {};
+  const agentSourcesDir = path.join(projectRoot, DIRS.agents);
+  const files = await glob("**/agent.yaml", agentSourcesDir);
+  for (const file of files) {
+    const fullPath = path.join(agentSourcesDir, file);
+    const content = await readFile(fullPath);
+    const config = parseYaml(content);
+    const agentPath = path.dirname(file);
+    agents[config.id] = {
+      title: config.title,
+      description: config.description,
+      model: config.model,
+      tools: config.tools,
+      path: agentPath,
+      sourceRoot: projectRoot,
+      skills: config.skills
+    };
+    verbose(`Loaded agent: ${config.id} from ${file}`);
+  }
+  return agents;
+}
+async function buildIdToDirectoryPathMap(skillsDir) {
+  const map = {};
+  const files = await glob("**/SKILL.md", skillsDir);
+  for (const file of files) {
+    const fullPath = path.join(skillsDir, file);
+    const content = await readFile(fullPath);
+    const frontmatter = parseFrontmatter(content);
+    if (frontmatter?.name) {
+      const directoryPath = file.replace("/SKILL.md", "");
+      map[frontmatter.name] = directoryPath;
+      map[directoryPath] = directoryPath;
+    }
+  }
+  return map;
+}
+async function loadSkillsByIds(skillIds, projectRoot) {
+  const skills = {};
+  const skillsDir = path.join(projectRoot, DIRS.skills);
+  const idToDirectoryPath = await buildIdToDirectoryPathMap(skillsDir);
+  const allSkillIds = Object.keys(idToDirectoryPath);
+  const expandedSkillIds = [];
+  for (const { id: skillId } of skillIds) {
+    if (idToDirectoryPath[skillId]) {
+      expandedSkillIds.push(skillId);
+    } else {
+      const childSkills = allSkillIds.filter((id) => {
+        const dirPath = idToDirectoryPath[id];
+        return dirPath.startsWith(skillId + "/");
+      });
+      if (childSkills.length > 0) {
+        expandedSkillIds.push(...childSkills);
+        verbose(
+          `Expanded directory '${skillId}' to ${childSkills.length} skills`
+        );
+      } else {
+        console.warn(`  Warning: Unknown skill reference '${skillId}'`);
+      }
+    }
+  }
+  const uniqueSkillIds = [...new Set(expandedSkillIds)];
+  for (const skillId of uniqueSkillIds) {
+    const directoryPath = idToDirectoryPath[skillId];
+    if (!directoryPath) {
+      console.warn(
+        `  Warning: Could not find skill ${skillId}: No matching skill found`
+      );
+      continue;
+    }
+    const skillPath = path.join(skillsDir, directoryPath);
+    const skillMdPath = path.join(skillPath, "SKILL.md");
+    try {
+      const content = await readFile(skillMdPath);
+      const frontmatter = parseFrontmatter(content);
+      if (!frontmatter) {
+        console.warn(
+          `  Warning: Skipping ${skillId}: Missing or invalid frontmatter`
+        );
+        continue;
+      }
+      const canonicalId = frontmatter.name;
+      const skillDef = {
+        path: `${DIRS.skills}/${directoryPath}/`,
+        name: extractDisplayName(frontmatter.name),
+        description: frontmatter.description,
+        canonicalId
+      };
+      skills[canonicalId] = skillDef;
+      if (directoryPath !== canonicalId) {
+        skills[directoryPath] = skillDef;
+      }
+      verbose(`Loaded skill: ${canonicalId} (from ${directoryPath})`);
+    } catch (error) {
+      console.warn(`  Warning: Could not load skill ${skillId}: ${error}`);
+    }
+  }
+  return skills;
+}
+async function loadPluginSkills(pluginDir) {
+  const skills = {};
+  const pluginSkillsDir = path.join(pluginDir, "skills");
+  if (!await directoryExists(pluginSkillsDir)) {
+    return skills;
+  }
+  const files = await glob("**/SKILL.md", pluginSkillsDir);
+  for (const file of files) {
+    const fullPath = path.join(pluginSkillsDir, file);
+    const content = await readFile(fullPath);
+    const frontmatter = parseFrontmatter(content);
+    if (!frontmatter) {
+      console.warn(
+        `  Warning: Skipping ${file}: Missing or invalid frontmatter`
+      );
+      continue;
+    }
+    const folderPath = file.replace("/SKILL.md", "");
+    const skillPath = `skills/${folderPath}/`;
+    const skillId = frontmatter.name;
+    skills[skillId] = {
+      path: skillPath,
+      name: extractDisplayName(frontmatter.name),
+      description: frontmatter.description,
+      canonicalId: skillId
+    };
+    verbose(`Loaded plugin skill: ${skillId} from ${file}`);
+  }
+  return skills;
+}
+
+// src/cli-v2/lib/stacks-loader.ts
+init_esm_shims();
+import { parse as parseYaml2 } from "yaml";
+import path2 from "path";
+var STACKS_FILE = "config/stacks.yaml";
+var stacksCache = /* @__PURE__ */ new Map();
+async function loadStacks(configDir) {
+  const cacheKey = configDir;
+  const cached = stacksCache.get(cacheKey);
+  if (cached) return cached;
+  const stacksPath = path2.join(configDir, STACKS_FILE);
+  if (!await fileExists(stacksPath)) {
+    verbose(`No stacks file found at ${stacksPath}`);
+    return [];
+  }
+  try {
+    const content = await readFile(stacksPath);
+    const config = parseYaml2(content);
+    if (!config.stacks || !Array.isArray(config.stacks)) {
+      verbose(`Invalid stacks.yaml format: missing stacks array`);
+      return [];
+    }
+    stacksCache.set(cacheKey, config.stacks);
+    verbose(`Loaded ${config.stacks.length} stacks from ${stacksPath}`);
+    return config.stacks;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to load stacks from '${stacksPath}': ${errorMessage}`
+    );
+  }
+}
+async function loadStackById(stackId, configDir) {
+  const stacks = await loadStacks(configDir);
+  const stack = stacks.find((s) => s.id === stackId);
+  if (!stack) {
+    verbose(`Stack '${stackId}' not found`);
+    return null;
+  }
+  verbose(`Found stack: ${stack.name} (${stackId})`);
+  return stack;
+}
+var KEY_SUBCATEGORIES = /* @__PURE__ */ new Set([
+  "framework",
+  "api",
+  "database",
+  "meta-framework",
+  "base-framework",
+  "platform"
+]);
+function resolveAgentConfigToSkills(agentConfig, skillAliases) {
+  const skillRefs = [];
+  for (const [subcategory, technologyAlias] of Object.entries(agentConfig)) {
+    const fullSkillId = skillAliases[technologyAlias];
+    if (!fullSkillId) {
+      verbose(
+        `Warning: No skill alias found for '${technologyAlias}' (subcategory: ${subcategory}). Skipping.`
+      );
+      continue;
+    }
+    const isKeySkill = KEY_SUBCATEGORIES.has(subcategory);
+    skillRefs.push({
+      id: fullSkillId,
+      usage: `when working with ${subcategory}`,
+      preloaded: isKeySkill
+    });
+  }
+  return skillRefs;
+}
+
+// src/cli-v2/lib/matrix-loader.ts
+init_esm_shims();
+import { parse as parseYaml3 } from "yaml";
+import path3 from "path";
+async function loadSkillsMatrix(configPath) {
+  const content = await readFile(configPath);
+  const config = parseYaml3(content);
+  validateMatrixStructure(config, configPath);
+  verbose(`Loaded skills matrix: ${configPath}`);
+  return config;
+}
+function validateMatrixStructure(config, configPath) {
+  const requiredFields = [
+    "version",
+    "categories",
+    "relationships",
+    "skill_aliases"
+  ];
+  const missing = requiredFields.filter((field) => !(field in config));
+  if (missing.length > 0) {
+    throw new Error(
+      `Skills matrix at ${configPath} is missing required fields: ${missing.join(", ")}`
+    );
+  }
+  const relationshipFields = [
+    "conflicts",
+    "recommends",
+    "requires",
+    "alternatives"
+  ];
+  const missingRelationships = relationshipFields.filter(
+    (field) => !config.relationships || !(field in config.relationships)
+  );
+  if (missingRelationships.length > 0) {
+    throw new Error(
+      `Skills matrix relationships missing required fields: ${missingRelationships.join(", ")}`
+    );
+  }
+  for (const [categoryId, category] of Object.entries(config.categories)) {
+    const requiredCategoryFields = [
+      "id",
+      "name",
+      "description",
+      "exclusive",
+      "required",
+      "order"
+    ];
+    const missingCategoryFields = requiredCategoryFields.filter(
+      (field) => !(field in category)
+    );
+    if (missingCategoryFields.length > 0) {
+      throw new Error(
+        `Category "${categoryId}" missing required fields: ${missingCategoryFields.join(", ")}`
+      );
+    }
+  }
+}
+async function extractAllSkills(skillsDir) {
+  const skills = [];
+  const metadataFiles = await glob("**/metadata.yaml", skillsDir);
+  for (const metadataFile of metadataFiles) {
+    const skillDir = path3.dirname(metadataFile);
+    const skillMdPath = path3.join(skillsDir, skillDir, "SKILL.md");
+    const metadataPath = path3.join(skillsDir, metadataFile);
+    if (!await fileExists(skillMdPath)) {
+      verbose(`Skipping ${metadataFile}: No SKILL.md found`);
+      continue;
+    }
+    const metadataContent = await readFile(metadataPath);
+    const metadata = parseYaml3(metadataContent);
+    const skillMdContent = await readFile(skillMdPath);
+    const frontmatter = parseFrontmatter(skillMdContent);
+    if (!frontmatter) {
+      verbose(`Skipping ${metadataFile}: Invalid SKILL.md frontmatter`);
+      continue;
+    }
+    if (!metadata.cli_name) {
+      throw new Error(
+        `Skill at ${metadataFile} is missing required 'cli_name' field in metadata.yaml`
+      );
+    }
+    const skillId = frontmatter.name;
+    const extracted = {
+      id: skillId,
+      directoryPath: skillDir,
+      name: metadata.cli_name,
+      description: metadata.cli_description || frontmatter.description,
+      usageGuidance: metadata.usage_guidance,
+      category: metadata.category,
+      categoryExclusive: metadata.category_exclusive ?? true,
+      author: metadata.author,
+      tags: metadata.tags ?? [],
+      compatibleWith: metadata.compatible_with ?? [],
+      conflictsWith: metadata.conflicts_with ?? [],
+      requires: metadata.requires ?? [],
+      requiresSetup: metadata.requires_setup ?? [],
+      providesSetupFor: metadata.provides_setup_for ?? [],
+      path: `skills/${skillDir}/`
+    };
+    skills.push(extracted);
+    verbose(`Extracted skill: ${skillId}`);
+  }
+  return skills;
+}
+function buildReverseAliases(aliases) {
+  const reverse = {};
+  for (const [alias, fullId] of Object.entries(aliases)) {
+    reverse[fullId] = alias;
+  }
+  return reverse;
+}
+function buildAliasTargetToSkillIdMap(aliases, skills) {
+  const map = {};
+  for (const skill of skills) {
+    const parts = skill.id.split("/");
+    const shortForm = parts[parts.length - 1];
+    if (shortForm && shortForm !== skill.id) {
+      map[shortForm] = skill.id;
+    }
+    if (skill.directoryPath && skill.directoryPath !== skill.id) {
+      map[skill.directoryPath] = skill.id;
+    }
+  }
+  const aliasTargets = new Set(Object.values(aliases));
+  for (const skill of skills) {
+    for (const aliasTarget of aliasTargets) {
+      if (aliasTarget !== skill.id && (skill.id.endsWith(`/${aliasTarget}`) || skill.id === aliasTarget)) {
+        map[aliasTarget] = skill.id;
+      }
+    }
+  }
+  return map;
+}
+function buildDirectoryPathToIdMap(skills) {
+  const map = {};
+  for (const skill of skills) {
+    if (skill.directoryPath && skill.directoryPath !== skill.id) {
+      map[skill.directoryPath] = skill.id;
+    }
+  }
+  return map;
+}
+function resolveToCanonicalId(aliasOrId, aliases, directoryPathToId = {}, aliasTargetToSkillId = {}) {
+  if (aliases[aliasOrId]) {
+    return aliases[aliasOrId];
+  }
+  if (directoryPathToId[aliasOrId]) {
+    return directoryPathToId[aliasOrId];
+  }
+  if (aliasTargetToSkillId[aliasOrId]) {
+    return aliasTargetToSkillId[aliasOrId];
+  }
+  return aliasOrId;
+}
+async function mergeMatrixWithSkills(matrix, skills) {
+  const aliases = matrix.skill_aliases;
+  const aliasesReverse = buildReverseAliases(aliases);
+  const directoryPathToId = buildDirectoryPathToIdMap(skills);
+  const aliasTargetToSkillId = buildAliasTargetToSkillIdMap(aliases, skills);
+  const resolvedSkills = {};
+  for (const skill of skills) {
+    const resolved = buildResolvedSkill(
+      skill,
+      matrix,
+      aliases,
+      aliasesReverse,
+      directoryPathToId,
+      aliasTargetToSkillId
+    );
+    resolvedSkills[skill.id] = resolved;
+  }
+  computeInverseRelationships(resolvedSkills);
+  const suggestedStacks = resolveSuggestedStacks(
+    matrix,
+    aliases,
+    aliasTargetToSkillId
+  );
+  const merged = {
+    version: matrix.version,
+    categories: matrix.categories,
+    skills: resolvedSkills,
+    suggestedStacks,
+    aliases,
+    aliasesReverse,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return merged;
+}
+function buildResolvedSkill(skill, matrix, aliases, aliasesReverse, directoryPathToId, aliasTargetToSkillId) {
+  const conflictsWith = [];
+  const recommends = [];
+  const requires = [];
+  const alternatives = [];
+  const discourages = [];
+  const resolve = (id) => resolveToCanonicalId(id, aliases, directoryPathToId, aliasTargetToSkillId);
+  for (const conflictRef of skill.conflictsWith) {
+    const canonicalId = resolve(conflictRef);
+    conflictsWith.push({
+      skillId: canonicalId,
+      reason: "Defined in skill metadata"
+    });
+  }
+  for (const conflictRule of matrix.relationships.conflicts) {
+    const resolvedSkills = conflictRule.skills.map(resolve);
+    if (resolvedSkills.includes(skill.id)) {
+      for (const otherSkill of resolvedSkills) {
+        if (otherSkill !== skill.id) {
+          if (!conflictsWith.some((c) => c.skillId === otherSkill)) {
+            conflictsWith.push({
+              skillId: otherSkill,
+              reason: conflictRule.reason
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const compatRef of skill.compatibleWith) {
+    const canonicalId = resolve(compatRef);
+    recommends.push({
+      skillId: canonicalId,
+      reason: "Compatible with this skill"
+    });
+  }
+  for (const recommendRule of matrix.relationships.recommends) {
+    const whenCanonicalId = resolve(recommendRule.when);
+    if (whenCanonicalId === skill.id) {
+      for (const suggested of recommendRule.suggest) {
+        const canonicalId = resolve(suggested);
+        if (!recommends.some((r) => r.skillId === canonicalId)) {
+          recommends.push({
+            skillId: canonicalId,
+            reason: recommendRule.reason
+          });
+        }
+      }
+    }
+  }
+  if (skill.requires.length > 0) {
+    requires.push({
+      skillIds: skill.requires.map(resolve),
+      needsAny: false,
+      reason: "Defined in skill metadata"
+    });
+  }
+  for (const requireRule of matrix.relationships.requires) {
+    const skillCanonicalId = resolve(requireRule.skill);
+    if (skillCanonicalId === skill.id) {
+      requires.push({
+        skillIds: requireRule.needs.map(resolve),
+        needsAny: requireRule.needs_any ?? false,
+        reason: requireRule.reason
+      });
+    }
+  }
+  for (const altGroup of matrix.relationships.alternatives) {
+    const resolvedAlts = altGroup.skills.map(resolve);
+    if (resolvedAlts.includes(skill.id)) {
+      for (const altSkill of resolvedAlts) {
+        if (altSkill !== skill.id) {
+          alternatives.push({
+            skillId: altSkill,
+            purpose: altGroup.purpose
+          });
+        }
+      }
+    }
+  }
+  if (matrix.relationships.discourages) {
+    for (const discourageRule of matrix.relationships.discourages) {
+      const resolvedSkills = discourageRule.skills.map(resolve);
+      if (resolvedSkills.includes(skill.id)) {
+        for (const otherSkill of resolvedSkills) {
+          if (otherSkill !== skill.id) {
+            if (!discourages.some((d) => d.skillId === otherSkill)) {
+              discourages.push({
+                skillId: otherSkill,
+                reason: discourageRule.reason
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    id: skill.id,
+    alias: aliasesReverse[skill.id],
+    name: skill.name,
+    description: skill.description,
+    usageGuidance: skill.usageGuidance,
+    category: skill.category,
+    categoryExclusive: skill.categoryExclusive,
+    tags: skill.tags,
+    author: skill.author,
+    conflictsWith,
+    recommends,
+    recommendedBy: [],
+    requires,
+    requiredBy: [],
+    alternatives,
+    discourages,
+    requiresSetup: skill.requiresSetup.map(resolve),
+    providesSetupFor: skill.providesSetupFor.map(resolve),
+    path: skill.path
+  };
+}
+function computeInverseRelationships(skills) {
+  for (const skill of Object.values(skills)) {
+    for (const recommend of skill.recommends) {
+      const targetSkill = skills[recommend.skillId];
+      if (targetSkill) {
+        targetSkill.recommendedBy.push({
+          skillId: skill.id,
+          reason: recommend.reason
+        });
+      }
+    }
+    for (const requirement of skill.requires) {
+      for (const requiredId of requirement.skillIds) {
+        const targetSkill = skills[requiredId];
+        if (targetSkill) {
+          targetSkill.requiredBy.push({
+            skillId: skill.id,
+            reason: requirement.reason
+          });
+        }
+      }
+    }
+  }
+}
+function resolveSuggestedStacks(matrix, aliases, aliasTargetToSkillId) {
+  if (!matrix.suggested_stacks) {
+    return [];
+  }
+  return matrix.suggested_stacks.map((stack) => {
+    const resolvedSkillsMap = {};
+    const allSkillIds = [];
+    for (const [category, subcategories] of Object.entries(stack.skills)) {
+      resolvedSkillsMap[category] = {};
+      for (const [subcategory, alias] of Object.entries(subcategories)) {
+        const aliasTarget = resolveToCanonicalId(alias, aliases);
+        const canonicalId = aliasTargetToSkillId[aliasTarget] || aliasTarget;
+        resolvedSkillsMap[category][subcategory] = canonicalId;
+        allSkillIds.push(canonicalId);
+      }
+    }
+    return {
+      id: stack.id,
+      name: stack.name,
+      description: stack.description,
+      audience: stack.audience,
+      skills: resolvedSkillsMap,
+      allSkillIds,
+      philosophy: stack.philosophy
+    };
+  });
+}
+
+export {
+  parseFrontmatter,
+  loadAllAgents,
+  loadSkillsByIds,
+  loadPluginSkills,
+  loadStacks,
+  loadStackById,
+  resolveAgentConfigToSkills,
+  loadSkillsMatrix,
+  extractAllSkills,
+  mergeMatrixWithSkills
+};
+//# sourceMappingURL=chunk-QGGSLMO3.js.map