squads-cli 0.2.0 → 0.2.1

package/dist/chunk-TYFTF53O.js

@@ -0,0 +1,613 @@
+#!/usr/bin/env node
+
+// src/lib/squad-parser.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, basename, dirname as dirname2 } from "path";
+import matter from "gray-matter";
+
+// src/lib/mcp-config.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+var SERVER_REGISTRY = {};
+function getHome() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+function getContextsDir() {
+  return join(getHome(), ".claude", "contexts");
+}
+function getMcpConfigsDir() {
+  return join(getHome(), ".claude", "mcp-configs");
+}
+function generateMcpConfig(mcpServers) {
+  const config = { mcpServers: {} };
+  for (const server of mcpServers) {
+    const def = SERVER_REGISTRY[server];
+    if (def) {
+      config.mcpServers[server] = def;
+    }
+  }
+  return config;
+}
+function writeMcpConfig(config, path) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, JSON.stringify(config, null, 2));
+}
+function readMcpConfig(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function resolveMcpConfig(squadName, mcpServers, forceRegenerate = false) {
+  const home = getHome();
+  const userOverride = join(getMcpConfigsDir(), `${squadName}.json`);
+  if (existsSync(userOverride)) {
+    const config = readMcpConfig(userOverride);
+    return {
+      path: userOverride,
+      source: "user-override",
+      servers: config ? Object.keys(config.mcpServers) : void 0
+    };
+  }
+  if (mcpServers && mcpServers.length > 0) {
+    const generatedPath = join(getContextsDir(), `${squadName}.mcp.json`);
+    const shouldGenerate = forceRegenerate || !existsSync(generatedPath);
+    if (shouldGenerate) {
+      const config2 = generateMcpConfig(mcpServers);
+      writeMcpConfig(config2, generatedPath);
+      return {
+        path: generatedPath,
+        source: "generated",
+        servers: Object.keys(config2.mcpServers),
+        generated: true
+      };
+    }
+    const config = readMcpConfig(generatedPath);
+    return {
+      path: generatedPath,
+      source: "generated",
+      servers: config ? Object.keys(config.mcpServers) : mcpServers,
+      generated: false
+    };
+  }
+  return {
+    path: join(home, ".claude.json"),
+    source: "fallback"
+  };
+}
+function resolveMcpConfigPath(squadName, mcpServers) {
+  return resolveMcpConfig(squadName, mcpServers).path;
+}
+
+// src/lib/squad-parser.ts
+function findSquadsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const squadsPath = join2(dir, ".agents", "squads");
+    if (existsSync2(squadsPath)) {
+      return squadsPath;
+    }
+    const parent = join2(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function findProjectRoot() {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  return join2(squadsDir, "..", "..");
+}
+function hasLocalInfraConfig() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return false;
+  const envPath = join2(projectRoot, ".env");
+  if (!existsSync2(envPath)) return false;
+  const content = readFileSync2(envPath, "utf-8");
+  const infraKeys = ["LANGFUSE_", "SQUADS_BRIDGE", "SQUADS_POSTGRES", "SQUADS_REDIS"];
+  return infraKeys.some((key) => content.includes(key));
+}
+function listSquads(squadsDir) {
+  const squads = [];
+  const entries = readdirSync(squadsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith("_")) {
+      const squadFile = join2(squadsDir, entry.name, "SQUAD.md");
+      if (existsSync2(squadFile)) {
+        squads.push(entry.name);
+      }
+    }
+  }
+  return squads;
+}
+function findSimilarSquads(input, squads) {
+  const lower = input.toLowerCase();
+  function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from(
+      { length: m + 1 },
+      (_, i) => Array.from({ length: n + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+    );
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+      }
+    }
+    return dp[m][n];
+  }
+  const threshold = Math.max(2, Math.floor(input.length / 3));
+  return squads.map((s) => ({ name: s, dist: levenshtein(lower, s.toLowerCase()) })).filter(({ name, dist }) => dist <= threshold || name.toLowerCase().includes(lower) || lower.includes(name.toLowerCase())).sort((a, b) => a.dist - b.dist).slice(0, 3).map(({ name }) => name);
+}
+function listAgents(squadsDir, squadName) {
+  const agents = [];
+  const dirs = squadName ? [squadName] : readdirSync(squadsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_")).map((e) => e.name);
+  for (const dir of dirs) {
+    const squadPath = join2(squadsDir, dir);
+    if (!existsSync2(squadPath)) continue;
+    const files = readdirSync(squadPath);
+    for (const file of files) {
+      if (file.endsWith(".md") && file !== "SQUAD.md") {
+        const agentName = file.replace(".md", "");
+        agents.push({
+          name: agentName,
+          role: `Agent in ${dir}`,
+          trigger: "manual",
+          filePath: join2(squadPath, file)
+        });
+      }
+    }
+  }
+  return agents;
+}
+function parseSquadFile(filePath) {
+  const rawContent = readFileSync2(filePath, "utf-8");
+  const { data: frontmatter, content: bodyContent } = matter(rawContent);
+  const fm = frontmatter;
+  const lines = bodyContent.split("\n");
+  const dirName = basename(dirname2(filePath));
+  const squad = {
+    // Display name can be different from dir (e.g., "Engineering Squad")
+    name: fm.name || dirName,
+    // Directory name for file path resolution
+    dir: dirName,
+    mission: fm.mission || "",
+    agents: [],
+    pipelines: [],
+    triggers: { scheduled: [], event: [], manual: [] },
+    routines: [],
+    dependencies: [],
+    outputPath: "",
+    goals: [],
+    // Apply frontmatter fields
+    effort: fm.effort,
+    context: fm.context,
+    repo: fm.repo,
+    stack: fm.stack,
+    providers: fm.providers,
+    // Preserve raw frontmatter for KPIs and other custom fields
+    frontmatter,
+    // Phase ordering: which squads must complete before this one
+    depends_on: Array.isArray(fm.depends_on) ? fm.depends_on : void 0
+  };
+  let currentSection = "";
+  let inTable = false;
+  let tableHeaders = [];
+  for (const line of lines) {
+    if (line.startsWith("# Squad:")) {
+      squad.name = line.replace("# Squad:", "").trim().toLowerCase();
+      continue;
+    }
+    if (line.startsWith("## ")) {
+      currentSection = line.replace("## ", "").trim().toLowerCase();
+      inTable = false;
+      continue;
+    }
+    if (currentSection === "mission" && line.trim() && !line.startsWith("#")) {
+      if (!squad.mission) {
+        squad.mission = line.trim();
+      }
+    }
+    const effortMatch = line.match(/^effort:\s*(high|medium|low)/i);
+    if (effortMatch && !squad.effort) {
+      squad.effort = effortMatch[1].toLowerCase();
+    }
+    if (currentSection.includes("agent") || currentSection.includes("orchestrator") || currentSection.includes("evaluator") || currentSection.includes("builder") || currentSection.includes("priority")) {
+      if (line.includes("|") && line.includes("Agent")) {
+        inTable = true;
+        tableHeaders = line.split("|").map((h) => h.trim().toLowerCase());
+        continue;
+      }
+      if (inTable && line.includes("|") && !line.includes("---")) {
+        const cells = line.split("|").map((c) => c.trim().replace(/`/g, "").replace(/\*\*/g, ""));
+        const agentIdx = tableHeaders.findIndex((h) => h === "agent");
+        const roleIdx = tableHeaders.findIndex((h) => h === "role");
+        const triggerIdx = tableHeaders.findIndex((h) => h === "trigger");
+        const statusIdx = tableHeaders.findIndex((h) => h === "status");
+        const effortIdx = tableHeaders.findIndex((h) => h === "effort");
+        if (agentIdx >= 0 && cells[agentIdx]) {
+          const effortValue = effortIdx >= 0 ? cells[effortIdx]?.toLowerCase() : void 0;
+          const effort = ["high", "medium", "low"].includes(effortValue || "") ? effortValue : void 0;
+          squad.agents.push({
+            name: cells[agentIdx],
+            role: roleIdx >= 0 ? cells[roleIdx] : "",
+            trigger: triggerIdx >= 0 ? cells[triggerIdx] : "manual",
+            status: statusIdx >= 0 ? cells[statusIdx] : "active",
+            effort
+          });
+        }
+      }
+    }
+    if (line.includes("\u2192") && line.includes("`")) {
+      const pipelineMatch = line.match(/`([^`]+)`\s*→\s*`([^`]+)`/g);
+      if (pipelineMatch) {
+        const agentNames = line.match(/`([^`]+)`/g)?.map((m) => m.replace(/`/g, "")) || [];
+        if (agentNames.length >= 2) {
+          squad.pipelines.push({
+            name: "default",
+            agents: agentNames
+          });
+        }
+      }
+    }
+    if (line.toLowerCase().includes("pipeline:")) {
+      const pipelineContent = line.split(":")[1];
+      if (pipelineContent && pipelineContent.includes("\u2192")) {
+        const agentNames = pipelineContent.match(/`([^`]+)`/g)?.map((m) => m.replace(/`/g, "")) || [];
+        if (agentNames.length >= 2) {
+          squad.pipelines.push({
+            name: "default",
+            agents: agentNames
+          });
+        }
+      }
+    }
+    if (line.toLowerCase().includes("primary") && line.includes("`")) {
+      const match = line.match(/`([^`]+)`/);
+      if (match) {
+        squad.outputPath = match[1].replace(/\/$/, "");
+      }
+    }
+    if (currentSection === "goals") {
+      const goalMatch = line.match(/^-\s*\[([ x])\]\s*(.+)$/);
+      if (goalMatch) {
+        const completed = goalMatch[1] === "x";
+        let description = goalMatch[2].trim();
+        let progress;
+        const progressMatch = description.match(/\(progress:\s*([^)]+)\)/i);
+        if (progressMatch) {
+          progress = progressMatch[1];
+          description = description.replace(progressMatch[0], "").trim();
+        }
+        squad.goals.push({
+          description,
+          completed,
+          progress
+        });
+      }
+    }
+  }
+  return squad;
+}
+function loadSquad(squadName) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  const squadFile = join2(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync2(squadFile)) return null;
+  return parseSquadFile(squadFile);
+}
+function loadAgentDefinition(agentPath) {
+  if (!existsSync2(agentPath)) return "";
+  return readFileSync2(agentPath, "utf-8");
+}
+function parseAgentProvider(agentPath) {
+  if (!existsSync2(agentPath)) return void 0;
+  const content = readFileSync2(agentPath, "utf-8");
+  try {
+    const { data: frontmatter } = matter(content);
+    if (frontmatter?.provider && typeof frontmatter.provider === "string") {
+      return frontmatter.provider.toLowerCase();
+    }
+  } catch {
+  }
+  const providerHeaderMatch = content.match(/##\s*Provider\s*\n+([a-zA-Z0-9_-]+)/i);
+  if (providerHeaderMatch) {
+    return providerHeaderMatch[1].toLowerCase();
+  }
+  return void 0;
+}
+function addGoalToSquad(squadName, goal) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return false;
+  const squadFile = join2(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync2(squadFile)) return false;
+  let content = readFileSync2(squadFile, "utf-8");
+  if (!content.includes("## Goals")) {
+    const insertPoint = content.indexOf("## Dependencies");
+    if (insertPoint > 0) {
+      content = content.slice(0, insertPoint) + `## Goals
+
+- [ ] ${goal}
+
+` + content.slice(insertPoint);
+    } else {
+      content += `
+## Goals
+
+- [ ] ${goal}
+`;
+    }
+  } else {
+    const goalsIdx = content.indexOf("## Goals");
+    const nextSectionIdx = content.indexOf("\n## ", goalsIdx + 1);
+    const endIdx = nextSectionIdx > 0 ? nextSectionIdx : content.length;
+    const goalsSection = content.slice(goalsIdx, endIdx);
+    const lastGoalMatch = goalsSection.match(/^-\s*\[[ x]\].+$/gm);
+    if (lastGoalMatch) {
+      const lastGoal = lastGoalMatch[lastGoalMatch.length - 1];
+      const lastGoalIdx = content.lastIndexOf(lastGoal, endIdx);
+      const insertPos = lastGoalIdx + lastGoal.length;
+      content = content.slice(0, insertPos) + `
+- [ ] ${goal}` + content.slice(insertPos);
+    } else {
+      const headerEnd = goalsIdx + "## Goals".length;
+      content = content.slice(0, headerEnd) + `
+
+- [ ] ${goal}` + content.slice(headerEnd);
+    }
+  }
+  writeFileSync2(squadFile, content);
+  return true;
+}
+function updateGoalInSquad(squadName, goalIndex, updates) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return false;
+  const squadFile = join2(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync2(squadFile)) return false;
+  const content = readFileSync2(squadFile, "utf-8");
+  const lines = content.split("\n");
+  let currentSection = "";
+  let goalCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      currentSection = line.replace("## ", "").trim().toLowerCase();
+      continue;
+    }
+    if (currentSection === "goals") {
+      const goalMatch = line.match(/^-\s*\[([ x])\]\s*(.+)$/);
+      if (goalMatch) {
+        if (goalCount === goalIndex) {
+          let newLine = "- [" + (updates.completed ? "x" : " ") + "] " + goalMatch[2];
+          if (updates.progress !== void 0) {
+            newLine = newLine.replace(/\s*\(progress:\s*[^)]+\)/i, "");
+            if (updates.progress) {
+              newLine += ` (progress: ${updates.progress})`;
+            }
+          }
+          lines[i] = newLine;
+          writeFileSync2(squadFile, lines.join("\n"));
+          return true;
+        }
+        goalCount++;
+      }
+    }
+  }
+  return false;
+}
+function findProjectSkillsDir() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return null;
+  const skillsDir = join2(projectRoot, ".claude", "skills");
+  return existsSync2(skillsDir) ? skillsDir : null;
+}
+function findGlobalSkillsDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  if (!home) return null;
+  const skillsDir = join2(home, ".claude", "skills");
+  return existsSync2(skillsDir) ? skillsDir : null;
+}
+function findSquadLocalSkillsDir(squadDir) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  const skillsDir = join2(squadsDir, squadDir, "skills");
+  return existsSync2(skillsDir) ? skillsDir : null;
+}
+function listSkillsInDir(skillsDir) {
+  if (!existsSync2(skillsDir)) return [];
+  try {
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillMdPath = join2(skillsDir, entry.name, "SKILL.md");
+        if (existsSync2(skillMdPath)) {
+          skills.push(entry.name);
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+        skills.push(entry.name.replace(".md", ""));
+      }
+    }
+    return skills;
+  } catch {
+    return [];
+  }
+}
+function findMemoryDir() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return null;
+  const memoryDir = join2(projectRoot, ".agents", "memory");
+  return existsSync2(memoryDir) ? memoryDir : null;
+}
+function resolveSkill(skillName, squadDir) {
+  if (squadDir) {
+    const squadSkillsDir = findSquadLocalSkillsDir(squadDir);
+    if (squadSkillsDir) {
+      const dirPath = join2(squadSkillsDir, skillName);
+      if (existsSync2(dirPath) && existsSync2(join2(dirPath, "SKILL.md"))) {
+        return { name: skillName, path: dirPath, source: "squad-local" };
+      }
+      const filePath = join2(squadSkillsDir, `${skillName}.md`);
+      if (existsSync2(filePath)) {
+        return { name: skillName, path: filePath, source: "squad-local" };
+      }
+    }
+  }
+  const projectSkillsDir = findProjectSkillsDir();
+  if (projectSkillsDir) {
+    const dirPath = join2(projectSkillsDir, skillName);
+    if (existsSync2(dirPath) && existsSync2(join2(dirPath, "SKILL.md"))) {
+      return { name: skillName, path: dirPath, source: "project" };
+    }
+    const filePath = join2(projectSkillsDir, `${skillName}.md`);
+    if (existsSync2(filePath)) {
+      return { name: skillName, path: filePath, source: "project" };
+    }
+  }
+  const globalSkillsDir = findGlobalSkillsDir();
+  if (globalSkillsDir) {
+    const dirPath = join2(globalSkillsDir, skillName);
+    if (existsSync2(dirPath) && existsSync2(join2(dirPath, "SKILL.md"))) {
+      return { name: skillName, path: dirPath, source: "global" };
+    }
+    const filePath = join2(globalSkillsDir, `${skillName}.md`);
+    if (existsSync2(filePath)) {
+      return { name: skillName, path: filePath, source: "global" };
+    }
+  }
+  return null;
+}
+function getSquadLocalSkills(squadDir) {
+  const squadSkillsDir = findSquadLocalSkillsDir(squadDir);
+  if (!squadSkillsDir) return [];
+  const skillNames = listSkillsInDir(squadSkillsDir);
+  const skills = [];
+  for (const name of skillNames) {
+    const resolved = resolveSkill(name, squadDir);
+    if (resolved && resolved.source === "squad-local") {
+      skills.push(resolved);
+    }
+  }
+  return skills;
+}
+function resolveMemoryPaths(patterns) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return [];
+  const resolved = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const subdir = pattern.slice(0, -2);
+      const subdirPath = join2(memoryDir, subdir);
+      if (existsSync2(subdirPath)) {
+        try {
+          const files = readdirSync(subdirPath);
+          for (const file of files) {
+            if (file.endsWith(".md")) {
+              resolved.push(join2(subdirPath, file));
+            }
+          }
+        } catch {
+        }
+      }
+    } else {
+      const fullPath = join2(memoryDir, pattern);
+      if (existsSync2(fullPath)) {
+        resolved.push(fullPath);
+      }
+    }
+  }
+  return resolved;
+}
+function findSquadLocalMcpConfig(squadDir) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  const mcpConfigPath = join2(squadsDir, squadDir, "mcp.json");
+  return existsSync2(mcpConfigPath) ? mcpConfigPath : null;
+}
+function resolveExecutionContext(squad, forceRegenerate = false) {
+  const ctx = squad.context || {};
+  const squadLocalMcpConfig = findSquadLocalMcpConfig(squad.dir);
+  let mcpConfigPath;
+  let mcpSource;
+  let mcpServers = [];
+  if (squadLocalMcpConfig) {
+    mcpConfigPath = squadLocalMcpConfig;
+    mcpSource = "squad-local";
+    try {
+      const content = readFileSync2(squadLocalMcpConfig, "utf-8");
+      const config = JSON.parse(content);
+      mcpServers = Object.keys(config.mcpServers || {});
+    } catch {
+    }
+  } else {
+    const mcpResolution = resolveMcpConfig(
+      squad.name,
+      ctx.mcp,
+      forceRegenerate
+    );
+    mcpConfigPath = mcpResolution.path;
+    mcpSource = mcpResolution.source;
+    mcpServers = mcpResolution.servers || [];
+  }
+  const resolvedSkills = [];
+  const skillPaths = [];
+  const squadLocalSkills = getSquadLocalSkills(squad.dir);
+  for (const skill of squadLocalSkills) {
+    resolvedSkills.push(skill);
+    skillPaths.push(skill.path);
+  }
+  if (ctx.skills) {
+    for (const skillName of ctx.skills) {
+      if (resolvedSkills.some((s) => s.name === skillName)) {
+        continue;
+      }
+      const resolved = resolveSkill(skillName, squad.dir);
+      if (resolved) {
+        resolvedSkills.push(resolved);
+        skillPaths.push(resolved.path);
+      }
+    }
+  }
+  const memoryPaths = ctx.memory?.load ? resolveMemoryPaths(ctx.memory.load) : [];
+  return {
+    // Copy all SquadContext fields
+    ...ctx,
+    // Add squad name
+    squadName: squad.name,
+    // Add resolved paths
+    resolved: {
+      mcpConfigPath,
+      mcpSource,
+      mcpServers,
+      skillPaths,
+      // Backward compatible
+      skills: resolvedSkills,
+      // New detailed skill info
+      memoryPaths
+    }
+  };
+}
+
+export {
+  resolveMcpConfigPath,
+  findSquadsDir,
+  findProjectRoot,
+  hasLocalInfraConfig,
+  listSquads,
+  findSimilarSquads,
+  listAgents,
+  parseSquadFile,
+  loadSquad,
+  loadAgentDefinition,
+  parseAgentProvider,
+  addGoalToSquad,
+  updateGoalInSquad,
+  getSquadLocalSkills,
+  resolveExecutionContext
+};
+//# sourceMappingURL=chunk-TYFTF53O.js.map