squads-cli 0.6.2 → 0.7.0

package/dist/sync-HJZJNXHW.js

@@ -0,0 +1,800 @@
+#!/usr/bin/env node
+import {
+  Events,
+  track
+} from "./chunk-L6GQCHDF.js";
+import {
+  findSquadsDir
+} from "./chunk-LDM62TIX.js";
+import {
+  findMemoryDir
+} from "./chunk-ZTQ7ISUR.js";
+import {
+  RESET,
+  colors,
+  gradient,
+  icons,
+  writeLine
+} from "./chunk-N7KDWU4W.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/commands/sync.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+
+// src/lib/cycle-sync.ts
+async function syncAllCycleData() {
+  return {
+    goals: { synced: 0, skipped: 0, errors: 0 },
+    feedback: { synced: 0, skipped: 0, errors: 0 },
+    kpis: { synced: 0, skipped: 0, errors: 0 },
+    learnings: { synced: 0, skipped: 0, errors: 0 },
+    duration: 0
+  };
+}
+async function isPostgresAvailable() {
+  return false;
+}
+async function closeCycleSyncPool() {
+}
+
+// src/commands/sync.ts
+var PATH_TO_SQUAD = {
+  "squads-cli": "product",
+  "agents-squads-web": "website",
+  "research": "research",
+  "intelligence": "intelligence",
+  "customer": "customer",
+  "finance": "finance",
+  "engineering": "engineering",
+  "product": "product",
+  "company": "company",
+  ".agents/squads": "engineering",
+  ".agents/memory": "engineering"
+};
+var MESSAGE_TO_SQUAD = {
+  "cli": "product",
+  "website": "website",
+  "web": "website",
+  "homepage": "website",
+  "research": "research",
+  "intel": "intelligence",
+  "lead": "customer",
+  "finance": "finance",
+  "cost": "finance",
+  "engineering": "engineering",
+  "infra": "engineering"
+};
+function getLastSyncTime(memoryDir) {
+  const syncFile = join(memoryDir, ".last-sync");
+  if (existsSync(syncFile)) {
+    return readFileSync(syncFile, "utf-8").trim();
+  }
+  return null;
+}
+function updateLastSyncTime(memoryDir) {
+  const syncFile = join(memoryDir, ".last-sync");
+  writeFileSync(syncFile, (/* @__PURE__ */ new Date()).toISOString());
+}
+function getRecentCommits(since) {
+  const commits = [];
+  try {
+    const sinceArg = since ? `--since="${since}"` : "-n 20";
+    const logOutput = execSync(
+      `git log ${sinceArg} --format="%H|%aI|%s" --name-only`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!logOutput) return commits;
+    const entries = logOutput.split("\n\n");
+    for (const entry of entries) {
+      const lines = entry.split("\n").filter((l) => l.trim());
+      if (lines.length === 0) continue;
+      const [header, ...fileLines] = lines;
+      const [hash, date, ...messageParts] = header.split("|");
+      const message = messageParts.join("|");
+      if (hash && date && message) {
+        commits.push({
+          hash: hash.substring(0, 7),
+          date: date.split("T")[0],
+          message,
+          files: fileLines.filter((f) => f && !f.includes("|"))
+        });
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error("Git log failed (not a git repo or other error):", err);
+    }
+  }
+  return commits;
+}
+function detectSquadsFromCommit(commit) {
+  const squads = /* @__PURE__ */ new Set();
+  for (const file of commit.files) {
+    for (const [pathPattern, squad] of Object.entries(PATH_TO_SQUAD)) {
+      if (file.includes(pathPattern)) {
+        squads.add(squad);
+      }
+    }
+  }
+  const msgLower = commit.message.toLowerCase();
+  for (const [keyword, squad] of Object.entries(MESSAGE_TO_SQUAD)) {
+    if (msgLower.includes(keyword)) {
+      squads.add(squad);
+    }
+  }
+  return Array.from(squads);
+}
+function groupCommitsBySquad(commits) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const squads = detectSquadsFromCommit(commit);
+    for (const squad of squads) {
+      if (!grouped.has(squad)) {
+        grouped.set(squad, []);
+      }
+      grouped.get(squad).push(commit);
+    }
+  }
+  return grouped;
+}
+function generateSummary(commits) {
+  if (commits.length === 0) return "";
+  const messages = commits.map((c) => `- ${c.message}`).join("\n");
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `
+## Session Update (${date})
+
+${messages}
+`;
+}
+function appendToSquadMemory(memoryDir, squad, summary) {
+  const squadMemoryDir = join(memoryDir, squad);
+  if (!existsSync(squadMemoryDir)) {
+    mkdirSync(squadMemoryDir, { recursive: true });
+  }
+  let agentDir;
+  const existingDirs = existsSync(squadMemoryDir) ? readdirSync(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
+  if (existingDirs.length > 0) {
+    agentDir = join(squadMemoryDir, existingDirs[0]);
+  } else {
+    agentDir = join(squadMemoryDir, `${squad}-lead`);
+    mkdirSync(agentDir, { recursive: true });
+  }
+  const statePath = join(agentDir, "state.md");
+  let content = "";
+  if (existsSync(statePath)) {
+    content = readFileSync(statePath, "utf-8");
+  } else {
+    content = `# ${squad} Squad - State
+
+Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+`;
+  }
+  content = content.replace(
+    /Updated:\s*\d{4}-\d{2}-\d{2}/,
+    `Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
+  );
+  content += summary;
+  writeFileSync(statePath, content);
+  return true;
+}
+function gitPullMemory() {
+  try {
+    execSync("git fetch origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const status = execSync("git status -sb", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const behindMatch = status.match(/behind (\d+)/);
+    const aheadMatch = status.match(/ahead (\d+)/);
+    const behind = behindMatch ? parseInt(behindMatch[1]) : 0;
+    const ahead = aheadMatch ? parseInt(aheadMatch[1]) : 0;
+    if (behind === 0) {
+      return { success: true, output: "Already up to date", behind: 0, ahead };
+    }
+    const output = execSync("git pull --rebase origin main", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { success: true, output: output.trim(), behind, ahead };
+  } catch (error) {
+    const err = error;
+    return { success: false, output: err.message || "Pull failed", behind: 0, ahead: 0 };
+  }
+}
+async function syncDimensionsToPostgres(verbose) {
+  const squadsDir = findSquadsDir();
+  const bridgeUrl = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
+  if (!squadsDir) {
+    writeLine(`  ${colors.red}No .agents/squads directory found${RESET}`);
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}sync --dimensions${RESET}`);
+  writeLine();
+  writeLine(`  ${icons.progress} Collecting squad definitions...`);
+  const squadDirs = readdirSync(squadsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  const squadsData = [];
+  const agentsData = [];
+  const { loadSquad: loadSquadFn } = await import("./squad-parser-CM3HOIWM.js");
+  for (const squadName of squadDirs) {
+    const squad = loadSquadFn(squadName);
+    if (!squad) continue;
+    squadsData.push({
+      name: squad.name,
+      mission: squad.mission || null,
+      domain: squad.domain || null,
+      default_provider: squad.providers?.default || "anthropic",
+      daily_budget: squad.context?.budget?.daily || 50,
+      cooldown_seconds: squad.context?.cooldown || 300,
+      metadata: {
+        providers: squad.providers,
+        context: squad.context,
+        permissions: squad.permissions
+      }
+    });
+    for (const agent of squad.agents) {
+      const agentPath = join(squadsDir, squadName, `${agent.name}.md`);
+      if (!existsSync(agentPath)) continue;
+      const definition = readFileSync(agentPath, "utf-8");
+      const mcpServers = extractMcpServersFromDef(definition);
+      const skills = extractSkillsFromDef(definition);
+      agentsData.push({
+        name: agent.name,
+        squad: squadName,
+        role: agent.role || null,
+        purpose: agent.purpose || null,
+        provider: agent.provider || null,
+        trigger_type: agent.trigger?.toLowerCase() || "manual",
+        mcp_servers: mcpServers,
+        skills,
+        metadata: {
+          schedule: agent.schedule,
+          outputs: agent.outputs
+        }
+      });
+    }
+  }
+  writeLine(`  ${icons.success} Found ${colors.cyan}${squadsData.length}${RESET} squads, ${colors.cyan}${agentsData.length}${RESET} agents`);
+  if (verbose) {
+    writeLine();
+    for (const s of squadsData) {
+      writeLine(`    ${colors.cyan}${s.name}${RESET} ${colors.dim}(${s.metadata.providers ? "with providers" : "default"})${RESET}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${icons.progress} Syncing to Postgres...`);
+  try {
+    const response = await fetch(`${bridgeUrl}/api/sync/dimensions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ squads: squadsData, agents: agentsData })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Bridge returned ${response.status}: ${error}`);
+    }
+    const data = await response.json();
+    writeLine(`  ${icons.success} Synced ${colors.green}${data.synced_squads}${RESET} squads, ${colors.green}${data.synced_agents}${RESET} agents`);
+    writeLine();
+  } catch (error) {
+    writeLine(`  ${icons.error} ${colors.red}Sync failed: ${error}${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Is the bridge running? Check: curl ${bridgeUrl}/health${RESET}`);
+    writeLine();
+  }
+}
+function extractMcpServersFromDef(definition) {
+  const servers = /* @__PURE__ */ new Set();
+  const knownServers = ["chrome-devtools", "firecrawl", "context7", "huggingface"];
+  for (const server of knownServers) {
+    if (definition.toLowerCase().includes(server)) {
+      servers.add(server);
+    }
+  }
+  const mcpMatch = definition.match(/mcp:\s*\n((?:\s*-\s*\S+\s*\n?)+)/i);
+  if (mcpMatch) {
+    for (const line of mcpMatch[1].split("\n")) {
+      const m = line.match(/^\s*-\s*(\S+)/);
+      if (m) servers.add(m[1]);
+    }
+  }
+  return Array.from(servers);
+}
+function extractSkillsFromDef(definition) {
+  const skills = /* @__PURE__ */ new Set();
+  const skillsMatch = definition.match(/skills:\s*\n((?:\s*-\s*\S+\s*\n?)+)/i);
+  if (skillsMatch) {
+    for (const line of skillsMatch[1].split("\n")) {
+      const m = line.match(/^\s*-\s*(\S+)/);
+      if (m) skills.add(m[1]);
+    }
+  }
+  const slashSkills = definition.match(/\/[\w-]+/g);
+  if (slashSkills) {
+    for (const skill of slashSkills) {
+      if (!skill.startsWith("/exit") && !skill.startsWith("/help")) {
+        skills.add(skill.slice(1));
+      }
+    }
+  }
+  return Array.from(skills);
+}
+var COMMIT_CATEGORY_MAP = {
+  "feat": "success",
+  "fix": "failure",
+  "refactor": "pattern",
+  "perf": "pattern",
+  "docs": "tip",
+  "chore": "tip",
+  "test": "pattern",
+  "style": "tip"
+};
+var SIGNIFICANT_PATTERNS = [
+  { pattern: /\d+\s*(agents?|files?|components?)/i, weight: 2 },
+  // Batch operations
+  { pattern: /parallel|concurrent|async/i, weight: 2 },
+  // Parallelization
+  { pattern: /automat|hook|trigger/i, weight: 2 },
+  // Automation
+  { pattern: /integrat|connect|bridge/i, weight: 1.5 },
+  // Integration
+  { pattern: /improv|optim|enhanc|better/i, weight: 1.5 },
+  // Improvements
+  { pattern: /new|add|implement|create/i, weight: 1 }
+  // New features
+];
+function analyzeCommitsForLearnings(commits) {
+  const learnings = [];
+  const squadCommits = groupCommitsBySquad(commits);
+  for (const [squad, squadCommitList] of squadCommits) {
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const commit of squadCommitList) {
+      const match = commit.message.match(/^(\w+)(?:\(.*?\))?:\s*/);
+      const prefix = match ? match[1].toLowerCase() : "other";
+      if (!byCategory.has(prefix)) {
+        byCategory.set(prefix, []);
+      }
+      byCategory.get(prefix).push(commit);
+    }
+    for (const [prefix, categoryCommits] of byCategory) {
+      if (categoryCommits.length === 0) continue;
+      const category = COMMIT_CATEGORY_MAP[prefix] || "tip";
+      let significanceScore = categoryCommits.length;
+      const allMessages = categoryCommits.map((c) => c.message).join(" ");
+      for (const { pattern, weight } of SIGNIFICANT_PATTERNS) {
+        if (pattern.test(allMessages)) {
+          significanceScore *= weight;
+        }
+      }
+      if (significanceScore < 2) continue;
+      let insight;
+      if (categoryCommits.length === 1) {
+        insight = categoryCommits[0].message.replace(/^(\w+)(?:\(.*?\))?:\s*/, "");
+      } else {
+        const summaryParts = categoryCommits.slice(0, 3).map((c) => c.message.replace(/^(\w+)(?:\(.*?\))?:\s*/, ""));
+        insight = `${prefix}: ${summaryParts.join("; ")}${categoryCommits.length > 3 ? ` (+${categoryCommits.length - 3} more)` : ""}`;
+      }
+      const tags = /* @__PURE__ */ new Set();
+      for (const commit of categoryCommits) {
+        for (const file of commit.files) {
+          if (file.includes("agents")) tags.add("agents");
+          if (file.includes("memory")) tags.add("memory");
+          if (file.includes("cli")) tags.add("cli");
+          if (file.includes("web")) tags.add("web");
+          if (file.includes("hook")) tags.add("hooks");
+        }
+      }
+      learnings.push({
+        squad,
+        insight,
+        category,
+        tags: Array.from(tags),
+        context: categoryCommits.map((c) => c.hash).join(", ")
+      });
+    }
+  }
+  return learnings;
+}
+function appendAutoLearnings(memoryDir, learnings) {
+  let appended = 0;
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  for (const learning of learnings) {
+    const squadDir = join(memoryDir, learning.squad);
+    let agentDir;
+    if (existsSync(squadDir)) {
+      const dirs = readdirSync(squadDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      agentDir = dirs.length > 0 ? join(squadDir, dirs[0]) : join(squadDir, `${learning.squad}-lead`);
+    } else {
+      mkdirSync(squadDir, { recursive: true });
+      agentDir = join(squadDir, `${learning.squad}-lead`);
+    }
+    if (!existsSync(agentDir)) {
+      mkdirSync(agentDir, { recursive: true });
+    }
+    const learningsPath = join(agentDir, "learnings.md");
+    const categoryEmoji = {
+      success: "\u2713",
+      failure: "\u2717",
+      pattern: "\u25C6",
+      tip: "\u2192"
+    }[learning.category];
+    const tagsStr = learning.tags.length > 0 ? ` #${learning.tags.join(" #")}` : "";
+    const entry = `
+${date} ${categoryEmoji} **${learning.category.charAt(0).toUpperCase() + learning.category.slice(1)}**: ${learning.insight}${tagsStr}
+`;
+    let content = "";
+    if (existsSync(learningsPath)) {
+      content = readFileSync(learningsPath, "utf-8");
+      if (content.includes(learning.insight.slice(0, 50))) {
+        continue;
+      }
+    } else {
+      content = `# ${learning.squad} Squad - Learnings
+
+Auto-captured insights from session activity.
+`;
+    }
+    writeFileSync(learningsPath, content + entry);
+    appended++;
+  }
+  return appended;
+}
+function parseLearningsFile(filePath, squad, agent) {
+  const content = readFileSync(filePath, "utf-8");
+  const learnings = [];
+  const sections = content.split(/^##+ /m).filter(Boolean);
+  for (const section of sections) {
+    const lines = section.trim().split("\n");
+    const title = lines[0]?.trim();
+    const body = lines.slice(1).join("\n").trim();
+    if (!body || body.length < 20) continue;
+    let category = "insight";
+    const titleLower = title?.toLowerCase() || "";
+    if (titleLower.includes("what works") || titleLower.includes("success")) category = "success";
+    else if (titleLower.includes("what doesn't") || titleLower.includes("unsuccessful") || titleLower.includes("fail")) category = "failure";
+    else if (titleLower.includes("pattern")) category = "pattern";
+    else if (titleLower.includes("improvement") || titleLower.includes("next")) category = "tip";
+    let importance = "normal";
+    if (body.includes("**Learning**:") || body.includes("critical") || body.includes("P1")) importance = "high";
+    learnings.push({
+      squad,
+      agent,
+      content: title ? `## ${title}
+${body}` : body,
+      category,
+      importance,
+      source_file: filePath
+    });
+  }
+  const learningMatches = content.matchAll(/\*\*Learning\*\*:\s*(.+?)(?=\n\n|\n\*\*|$)/gs);
+  for (const match of learningMatches) {
+    learnings.push({
+      squad,
+      agent,
+      content: match[1].trim(),
+      category: "insight",
+      importance: "high",
+      source_file: filePath
+    });
+  }
+  return learnings;
+}
+async function syncLearningsToPostgres(verbose) {
+  const bridgeUrl = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
+  const memoryDir = findMemoryDir();
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}sync --learnings${RESET}`);
+  writeLine();
+  if (!memoryDir) {
+    writeLine(`  ${icons.error} ${colors.red}No .agents/memory directory found${RESET}`);
+    return;
+  }
+  writeLine(`  ${icons.progress} Scanning for learnings files...`);
+  const learningsFiles = [];
+  const scanDir = (dir) => {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDir(fullPath);
+      } else if (entry.name === "learnings.md") {
+        learningsFiles.push(fullPath);
+      }
+    }
+  };
+  scanDir(memoryDir);
+  writeLine(`  ${icons.success} Found ${colors.cyan}${learningsFiles.length}${RESET} learnings files`);
+  const allLearnings = [];
+  for (const file of learningsFiles) {
+    const relativePath = file.replace(memoryDir + "/", "");
+    const parts = relativePath.split("/");
+    const squad = parts[0] || "unknown";
+    const agent = parts.length > 2 ? parts[1] : null;
+    const entries = parseLearningsFile(file, squad, agent);
+    allLearnings.push(...entries);
+    if (verbose && entries.length > 0) {
+      writeLine(`    ${colors.cyan}${squad}${agent ? "/" + agent : ""}${RESET}: ${entries.length} learnings`);
+    }
+  }
+  writeLine(`  ${icons.success} Parsed ${colors.cyan}${allLearnings.length}${RESET} total learnings`);
+  if (allLearnings.length === 0) {
+    writeLine();
+    writeLine(`  ${colors.dim}No learnings to sync${RESET}`);
+    return;
+  }
+  writeLine();
+  writeLine(`  ${icons.progress} Syncing to Postgres...`);
+  try {
+    const response = await fetch(`${bridgeUrl}/api/sync/learnings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ learnings: allLearnings })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Bridge returned ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    writeLine(`  ${icons.success} Imported ${colors.green}${result.imported}${RESET} learnings${result.skipped > 0 ? `, skipped ${result.skipped} duplicates` : ""}`);
+  } catch (error) {
+    writeLine(`  ${icons.error} ${colors.red}Sync failed: ${error}${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Is the bridge running? Check: curl ${bridgeUrl}/health${RESET}`);
+  }
+  writeLine();
+}
+function gitPushMemory() {
+  try {
+    const status = execSync("git status --porcelain .agents/memory/", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (status) {
+      execSync("git add .agents/memory/", { stdio: ["pipe", "pipe", "pipe"] });
+      execSync('git commit -m "chore: sync squad memory"', {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    const output = execSync("git push origin main", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { success: true, output: output.trim() || "Pushed successfully" };
+  } catch (error) {
+    const err = error;
+    return { success: false, output: err.message || "Push failed" };
+  }
+}
+async function syncCommand(options = {}) {
+  await track(Events.CLI_MEMORY_SYNC, { push: options.push, pull: options.pull, postgres: options.postgres, dimensions: options.dimensions, learnings: options.learnings, autoLearn: options.autoLearn });
+  if (options.dimensions) {
+    await syncDimensionsToPostgres(options.verbose);
+    return;
+  }
+  if (options.learnings) {
+    await syncLearningsToPostgres(options.verbose);
+    return;
+  }
+  if (options.autoLearn) {
+    const memoryDir2 = findMemoryDir();
+    if (!memoryDir2) {
+      writeLine(`  ${colors.yellow}No .agents/memory directory found${RESET}`);
+      return;
+    }
+    writeLine();
+    writeLine(`  ${gradient("squads")} ${colors.dim}memory sync --auto-learn${RESET}`);
+    writeLine();
+    const lastSync2 = getLastSyncTime(memoryDir2);
+    const commits2 = getRecentCommits(lastSync2 || void 0);
+    if (commits2.length === 0) {
+      writeLine(`  ${colors.dim}No commits to analyze${RESET}`);
+      writeLine();
+      return;
+    }
+    writeLine(`  ${icons.progress} Analyzing ${colors.cyan}${commits2.length}${RESET} commits...`);
+    const learnings = analyzeCommitsForLearnings(commits2);
+    if (learnings.length === 0) {
+      writeLine(`  ${colors.dim}No significant patterns detected${RESET}`);
+      writeLine();
+      return;
+    }
+    writeLine(`  ${icons.success} Found ${colors.cyan}${learnings.length}${RESET} learnable patterns`);
+    writeLine();
+    if (options.verbose) {
+      for (const learning of learnings) {
+        const emoji = { success: "\u2713", failure: "\u2717", pattern: "\u25C6", tip: "\u2192" }[learning.category];
+        writeLine(`    ${colors.cyan}${learning.squad}${RESET} ${emoji} ${learning.insight.slice(0, 60)}${learning.insight.length > 60 ? "..." : ""}`);
+      }
+      writeLine();
+    }
+    const appended = appendAutoLearnings(memoryDir2, learnings);
+    writeLine(`  ${icons.success} Captured ${colors.green}${appended}${RESET} learnings to memory`);
+    const bySquad2 = /* @__PURE__ */ new Map();
+    for (const l of learnings) {
+      bySquad2.set(l.squad, (bySquad2.get(l.squad) || 0) + 1);
+    }
+    for (const [squad, count] of bySquad2) {
+      writeLine(`    ${colors.cyan}${squad}${RESET}: ${count} learnings`);
+    }
+    writeLine();
+    updateLastSyncTime(memoryDir2);
+    if (options.postgres) {
+      await syncLearningsToPostgres(options.verbose);
+    }
+    return;
+  }
+  const memoryDir = findMemoryDir();
+  const _squadsDir = findSquadsDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.yellow}No .agents/memory directory found${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}memory sync${RESET}`);
+  writeLine();
+  const doPull = options.pull !== false;
+  const doPush = options.push === true;
+  if (doPull) {
+    writeLine(`  ${icons.progress} Pulling from remote...`);
+    const pullResult = gitPullMemory();
+    if (pullResult.success) {
+      if (pullResult.behind > 0) {
+        writeLine(`  ${icons.success} Pulled ${colors.cyan}${pullResult.behind}${RESET} commits from remote`);
+      } else {
+        writeLine(`  ${icons.success} ${colors.dim}Already up to date${RESET}`);
+      }
+      if (pullResult.ahead > 0) {
+        writeLine(`  ${colors.dim}  ${pullResult.ahead} local commits to push${RESET}`);
+      }
+    } else {
+      writeLine(`  ${icons.error} ${colors.red}Pull failed: ${pullResult.output}${RESET}`);
+    }
+    writeLine();
+  }
+  const lastSync = getLastSyncTime(memoryDir);
+  if (lastSync) {
+    writeLine(`  ${colors.dim}Last sync: ${lastSync.split("T")[0]}${RESET}`);
+  } else {
+    writeLine(`  ${colors.dim}First sync${RESET}`);
+  }
+  writeLine();
+  const commits = getRecentCommits(lastSync || void 0);
+  if (commits.length === 0) {
+    writeLine(`  ${colors.yellow}No new commits since last sync${RESET}`);
+    if (options.postgres) {
+      writeLine();
+      writeLine(`  ${icons.progress} Syncing cycle data to Postgres...`);
+      const pgAvailable = await isPostgresAvailable();
+      if (!pgAvailable) {
+        writeLine(`  ${icons.error} ${colors.red}Postgres not available${RESET}`);
+        writeLine(`  ${colors.dim}Run \`squads stack up\` to start the database${RESET}`);
+      } else {
+        try {
+          const result = await syncAllCycleData();
+          const totalSynced = result.goals.synced + result.feedback.synced + result.kpis.synced + result.learnings.synced;
+          const totalErrors = result.goals.errors + result.feedback.errors + result.kpis.errors + result.learnings.errors;
+          if (totalSynced > 0 || totalErrors > 0) {
+            writeLine(`  ${icons.success} Synced to Postgres ${colors.dim}(${result.duration}ms)${RESET}`);
+            if (result.goals.synced > 0) {
+              writeLine(`    ${colors.dim}Goals:${RESET} ${colors.cyan}${result.goals.synced}${RESET}`);
+            }
+            if (result.feedback.synced > 0) {
+              writeLine(`    ${colors.dim}Feedback:${RESET} ${colors.cyan}${result.feedback.synced}${RESET}`);
+            }
+            if (result.kpis.synced > 0) {
+              writeLine(`    ${colors.dim}KPIs:${RESET} ${colors.cyan}${result.kpis.synced}${RESET}`);
+            }
+            if (result.learnings.synced > 0) {
+              writeLine(`    ${colors.dim}Learnings:${RESET} ${colors.cyan}${result.learnings.synced}${RESET}`);
+            }
+            if (totalErrors > 0) {
+              writeLine(`    ${colors.red}Errors:${RESET} ${totalErrors}`);
+            }
+          } else {
+            writeLine(`  ${icons.success} ${colors.dim}No new cycle data to sync${RESET}`);
+          }
+          await closeCycleSyncPool();
+        } catch (err) {
+          writeLine(`  ${icons.error} ${colors.red}Postgres sync failed${RESET}`);
+          if (process.env.DEBUG) console.error(err);
+        }
+      }
+    }
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.cyan}${commits.length}${RESET} commits to process`);
+  writeLine();
+  const bySquad = groupCommitsBySquad(commits);
+  if (bySquad.size === 0) {
+    writeLine(`  ${colors.yellow}No squad-related commits found${RESET}`);
+    writeLine();
+    updateLastSyncTime(memoryDir);
+    return;
+  }
+  let updated = 0;
+  for (const [squad, squadCommits] of bySquad) {
+    const summary = generateSummary(squadCommits);
+    if (options.verbose) {
+      writeLine(`  ${icons.progress} ${colors.cyan}${squad}${RESET}`);
+      for (const commit of squadCommits) {
+        writeLine(`    ${colors.dim}${commit.hash} ${commit.message}${RESET}`);
+      }
+    }
+    const success = appendToSquadMemory(memoryDir, squad, summary);
+    if (success) {
+      writeLine(`  ${icons.success} ${colors.cyan}${squad}${RESET} ${colors.dim}(${squadCommits.length} commits)${RESET}`);
+      updated++;
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.green}${updated}${RESET} squad memories updated`);
+  writeLine();
+  updateLastSyncTime(memoryDir);
+  if (doPush) {
+    writeLine(`  ${icons.progress} Pushing to remote...`);
+    const pushResult = gitPushMemory();
+    if (pushResult.success) {
+      writeLine(`  ${icons.success} ${colors.green}Pushed memory updates to remote${RESET}`);
+    } else {
+      writeLine(`  ${icons.error} ${colors.red}Push failed: ${pushResult.output}${RESET}`);
+    }
+    writeLine();
+  }
+  if (options.postgres) {
+    writeLine(`  ${icons.progress} Syncing cycle data to Postgres...`);
+    const pgAvailable = await isPostgresAvailable();
+    if (!pgAvailable) {
+      writeLine(`  ${icons.error} ${colors.red}Postgres not available${RESET}`);
+      writeLine(`  ${colors.dim}Run \`squads stack up\` to start the database${RESET}`);
+      writeLine();
+    } else {
+      try {
+        const result = await syncAllCycleData();
+        const totalSynced = result.goals.synced + result.feedback.synced + result.kpis.synced + result.learnings.synced;
+        const totalErrors = result.goals.errors + result.feedback.errors + result.kpis.errors + result.learnings.errors;
+        if (totalSynced > 0 || totalErrors > 0) {
+          writeLine(`  ${icons.success} Synced to Postgres ${colors.dim}(${result.duration}ms)${RESET}`);
+          if (result.goals.synced > 0) {
+            writeLine(`    ${colors.dim}Goals:${RESET} ${colors.cyan}${result.goals.synced}${RESET}`);
+          }
+          if (result.feedback.synced > 0) {
+            writeLine(`    ${colors.dim}Feedback:${RESET} ${colors.cyan}${result.feedback.synced}${RESET}`);
+          }
+          if (result.kpis.synced > 0) {
+            writeLine(`    ${colors.dim}KPIs:${RESET} ${colors.cyan}${result.kpis.synced}${RESET}`);
+          }
+          if (result.learnings.synced > 0) {
+            writeLine(`    ${colors.dim}Learnings:${RESET} ${colors.cyan}${result.learnings.synced}${RESET}`);
+          }
+          if (totalErrors > 0) {
+            writeLine(`    ${colors.red}Errors:${RESET} ${totalErrors}`);
+          }
+        } else {
+          writeLine(`  ${icons.success} ${colors.dim}No new cycle data to sync${RESET}`);
+        }
+        writeLine();
+        await closeCycleSyncPool();
+      } catch (err) {
+        writeLine(`  ${icons.error} ${colors.red}Postgres sync failed${RESET}`);
+        if (process.env.DEBUG) console.error(err);
+        writeLine();
+      }
+    }
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads memory show ${colors.cyan}<squad>${RESET}   ${colors.dim}View updated memory${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads status               ${colors.dim}See all squads${RESET}`);
+  if (!doPush && updated > 0) {
+    writeLine(`  ${colors.dim}$${RESET} squads memory sync --push   ${colors.dim}Push changes to remote${RESET}`);
+  }
+  if (!options.postgres) {
+    writeLine(`  ${colors.dim}$${RESET} squads memory sync --postgres  ${colors.dim}Sync to Postgres${RESET}`);
+  }
+  writeLine();
+}
+export {
+  syncCommand
+};
+//# sourceMappingURL=sync-HJZJNXHW.js.map