claude-code-swarm 0.3.23 → 0.3.25

package/src/__tests__/cognitive-core-loadout-e2e.test.mjs

@@ -0,0 +1,260 @@
+/**
+ * Cross-repo e2e — cognitive-core publishes skills → skill-tree storage →
+ * cc-swarm's compileAllRoleLoadouts materializes them via openteams template.
+ *
+ * Real components throughout, no mocks:
+ *   - cognitive-core's `convertPlaybookToSkill` + `SkillPublisher` (real
+ *     playbook → skill conversion, real write to FS storage)
+ *   - skill-tree's `createSkillBank` (real file-backed storage)
+ *   - cc-swarm's `compileAllRoleLoadouts` driving skill-tree's compile
+ *   - hand-built openteams template-shape that includes the published IDs
+ *
+ * What this proves:
+ *   - The metric-free Skill shape (post skill-tree 0.2 + cognitive-core
+ *     Phase 3) round-trips through both publish (write) and compile
+ *     (read) without losing any required fields.
+ *   - cc-swarm's bridge (`mergeOpenteamsSkillsIntoCriteria`) correctly
+ *     surfaces playbook-derived skills via `include: [...]`.
+ *   - The full chain works end-to-end across three packages.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { compileAllRoleLoadouts } from '../skilltree-client.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function depsAvailable() {
+  try {
+    const cwd = path.resolve(__dirname, '../..');
+    require.resolve('skill-tree', { paths: [cwd] });
+    require.resolve('cognitive-core', { paths: [cwd] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const SKIP = !depsAvailable();
+
+function makePlaybook(id, overrides = {}) {
+  // Minimal Playbook shape that cognitive-core's convertPlaybookToSkill
+  // can consume. Keeps imports light — we don't import createPlaybook
+  // here because cognitive-core's deep import paths aren't directly
+  // accessible from cc-swarm's runtime.
+  const now = new Date();
+  return {
+    id,
+    name: overrides.name ?? id,
+    applicability: {
+      situations: [overrides.situation ?? `Situation for ${id}`],
+      triggers: [],
+      antiPatterns: [],
+      domains: overrides.domains ?? ['testing'],
+    },
+    guidance: {
+      strategy: overrides.strategy ?? `Strategy: how to handle ${id}`,
+      tactics: overrides.tactics ?? [],
+      ...(overrides.codeExample && { codeExample: overrides.codeExample }),
+    },
+    verification: {
+      successIndicators: ['operation completes'],
+      failureIndicators: [],
+    },
+    evolution: {
+      version: overrides.version ?? '1.0.0',
+      createdFrom: ['session-x'],
+      failures: [],
+      refinements: [],
+      successCount: overrides.successCount ?? 5,
+      failureCount: overrides.failureCount ?? 1,
+      lastUsed: now,
+    },
+    provenance: { origin: 'extracted', recordedAt: now },
+    confidence: overrides.confidence ?? 0.85,
+    complexity: 'moderate',
+    estimatedEffort: 3,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+describe.skipIf(SKIP)(
+  'cross-repo e2e — cognitive-core skills → cc-swarm compile',
+  () => {
+    /** @type {string} */
+    let basePath;
+
+    beforeEach(async () => {
+      basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-cc-e2e-'));
+
+      // Use cognitive-core's publisher to write skills into a real
+      // skill-tree FilesystemStorageAdapter. This is the actual
+      // cross-repo handshake.
+      const ccCore = await import('cognitive-core');
+      const st = await import('skill-tree');
+
+      const bank = st.createSkillBank({ storage: { basePath } });
+      await bank.initialize();
+
+      const publisher = new ccCore.SkillPublisher(bank.getStorage());
+
+      await publisher.publishPlaybook(
+        makePlaybook('typescript-import-fix', {
+          situation: 'TypeScript ESM build emits "Cannot find module"',
+          strategy: 'Add .js extensions to all relative imports',
+          tactics: ['Use codemod', 'Verify with tsc --noEmit'],
+          domains: ['typescript', 'esm'],
+        }),
+      );
+      await publisher.publishPlaybook(
+        makePlaybook('react-rerender-bug', {
+          situation: 'Component re-renders on every parent update',
+          strategy: 'Wrap in React.memo and audit prop identity',
+          tactics: ['useCallback for callbacks', 'useMemo for objects'],
+          domains: ['react', 'performance'],
+        }),
+      );
+      await publisher.publishPlaybook(
+        makePlaybook('flaky-test-fix', {
+          situation: 'Test passes locally, fails in CI',
+          strategy: 'Eliminate timing dependencies with explicit waits',
+          domains: ['testing'],
+        }),
+      );
+
+      await bank.shutdown();
+    });
+
+    afterEach(() => {
+      fs.rmSync(basePath, { recursive: true, force: true });
+    });
+
+    it('cc-swarm compiles a loadout including a cognitive-core-published skill', async () => {
+      const manifest = { name: 'test-team', roles: ['developer'] };
+      const template = {
+        roles: new Map([
+          [
+            'developer',
+            {
+              loadout: {
+                skills: { include: ['typescript-import-fix'] },
+              },
+            },
+          ],
+        ]),
+      };
+
+      const result = await compileAllRoleLoadouts(
+        manifest,
+        { basePath },
+        template,
+      );
+
+      expect(result.developer).toBeDefined();
+      expect(result.developer.content.length).toBeGreaterThan(0);
+      // The skill content (from cognitive-core's convertPlaybookToSkill)
+      // should appear in the rendered system prompt
+      const lower = result.developer.content.toLowerCase();
+      expect(lower).toContain('typescript-import-fix');
+    });
+
+    it('all three published skills are retrievable by id via skill-tree', async () => {
+      const st = await import('skill-tree');
+      const bank = st.createSkillBank({ storage: { basePath } });
+      await bank.initialize();
+
+      const ts = await bank.getSkill('typescript-import-fix');
+      const react = await bank.getSkill('react-rerender-bug');
+      const test = await bank.getSkill('flaky-test-fix');
+
+      expect(ts).not.toBeNull();
+      expect(react).not.toBeNull();
+      expect(test).not.toBeNull();
+
+      // All three have NO metrics field — proves the metric-free shape
+      // survived publish and read across packages
+      for (const skill of [ts, react, test]) {
+        expect(skill.metrics).toBeUndefined();
+        expect(skill.author).toBe('cognitive-core');
+      }
+      await bank.shutdown();
+    });
+
+    it('cc-swarm openteams overlay (max_tokens) flows through into skill-tree compile', async () => {
+      // The bridge maps openteams `loadout.skills.max_tokens` → skill-tree
+      // `criteria.maxTokens` (rename). Use a low budget to verify the
+      // value reaches skill-tree's bundle limiter.
+      const manifest = { name: 'test-team', roles: ['developer'] };
+      const include = [
+        'typescript-import-fix',
+        'react-rerender-bug',
+        'flaky-test-fix',
+      ];
+      const buildTemplate = (max_tokens) => ({
+        roles: new Map([
+          ['developer', { loadout: { skills: { include, max_tokens } } }],
+        ]),
+      });
+
+      const low = await compileAllRoleLoadouts(
+        manifest,
+        { basePath },
+        buildTemplate(1),
+      );
+      const high = await compileAllRoleLoadouts(
+        manifest,
+        { basePath },
+        buildTemplate(100000),
+      );
+
+      const lowLen = low.developer?.content?.length ?? 0;
+      const highLen = high.developer?.content?.length ?? 0;
+      // High budget produces more content than effectively-zero budget —
+      // proves max_tokens flows through the bridge into the compile
+      expect(highLen).toBeGreaterThan(lowLen);
+    });
+
+    it('multiple roles bind to disjoint published skills', async () => {
+      const manifest = {
+        name: 'test-team',
+        roles: ['ts-dev', 'react-dev', 'qa'],
+      };
+      const template = {
+        roles: new Map([
+          [
+            'ts-dev',
+            { loadout: { skills: { include: ['typescript-import-fix'] } } },
+          ],
+          [
+            'react-dev',
+            { loadout: { skills: { include: ['react-rerender-bug'] } } },
+          ],
+          [
+            'qa',
+            { loadout: { skills: { include: ['flaky-test-fix'] } } },
+          ],
+        ]),
+      };
+
+      const result = await compileAllRoleLoadouts(
+        manifest,
+        { basePath },
+        template,
+      );
+
+      expect(result['ts-dev']?.content?.toLowerCase()).toContain(
+        'typescript-import-fix',
+      );
+      expect(result['react-dev']?.content?.toLowerCase()).toContain(
+        'react-rerender-bug',
+      );
+      expect(result['qa']?.content?.toLowerCase()).toContain(
+        'flaky-test-fix',
+      );
+    });
+  },
+);

package/src/__tests__/e2e-loadout-demo.test.mjs

@@ -0,0 +1,150 @@
+/**
+ * End-to-end integration test against the openteams loadout-demo template.
+ *
+ * Exercises the full loadout consumer path:
+ *   cacheLoadoutArtifacts — writes loadouts/, scope/, mcp-providers.json, mcp-health.json
+ *   generateAllAgents      — writes AGENT.md with enriched frontmatter
+ *
+ * Requires openteams >= 0.3 installed (or symlinked) under node_modules.
+ * The test skips gracefully if openteams is unavailable at runtime.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import yaml from "js-yaml";
+
+// Test file is at <root>/references/claude-code-swarm/src/__tests__/*.test.mjs
+// openteams demo is at <root>/references/openteams/examples/loadout-demo
+const LOADOUT_DEMO = path.resolve(
+  new URL("..", import.meta.url).pathname, // -> src/
+  "..", // -> claude-code-swarm/
+  "..", // -> references/
+  "openteams",
+  "examples",
+  "loadout-demo"
+);
+
+function openteamsAvailable() {
+  try {
+    const resolved = require.resolve
+      ? require.resolve("openteams", {
+          paths: [path.resolve(new URL("..", import.meta.url).pathname, "..")],
+        })
+      : null;
+    return !!resolved;
+  } catch {
+    return false;
+  }
+}
+
+const SKIP = !fs.existsSync(LOADOUT_DEMO);
+
+describe.skipIf(SKIP)("E2E — loadout-demo", () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "swarm-e2e-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("cacheLoadoutArtifacts writes per-role scope + team providers + health", async () => {
+    const { cacheLoadoutArtifacts } = await import("../template.mjs");
+    const outputDir = path.join(tmpDir, "artifacts");
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    cacheLoadoutArtifacts({
+      templatePath: LOADOUT_DEMO,
+      outputDir,
+      templateName: "loadout-demo",
+      teamName: "loadout-demo",
+    });
+
+    // Per-role artifacts written for roles that have loadouts
+    expect(fs.existsSync(path.join(outputDir, "loadouts", "implementer.json"))).toBe(true);
+    expect(fs.existsSync(path.join(outputDir, "loadouts", "reviewer.json"))).toBe(true);
+    // Planner in loadout-demo has no loadout — skipped
+    expect(fs.existsSync(path.join(outputDir, "loadouts", "planner.json"))).toBe(false);
+
+    // Scope files written for loadout-bearing roles
+    expect(fs.existsSync(path.join(outputDir, "scope", "implementer.json"))).toBe(true);
+    const reviewerScope = JSON.parse(
+      fs.readFileSync(path.join(outputDir, "scope", "reviewer.json"), "utf-8")
+    );
+    expect(reviewerScope.role).toBe("reviewer");
+    expect(reviewerScope.team).toBe("loadout-demo");
+    // Reviewer inline-extends security-auditor → should have chrome-devtools in scope
+    expect(reviewerScope.scope.some((s) => s.server === "chrome-devtools")).toBe(true);
+    // Deny list should accumulate through the inheritance chain
+    expect(reviewerScope.permissions.deny).toContain("Bash(git push:*)");
+
+    // Team providers cached
+    const providers = JSON.parse(
+      fs.readFileSync(path.join(outputDir, "mcp-providers.json"), "utf-8")
+    );
+    expect(Object.keys(providers)).toContain("ast-grep");
+    expect(Object.keys(providers)).toContain("chrome-devtools");
+    expect(providers["secrets-scanner"]?.ref).toBe("@openhive/secrets-scanner");
+
+    // Health report present
+    expect(fs.existsSync(path.join(outputDir, "mcp-health.json"))).toBe(true);
+    const health = JSON.parse(
+      fs.readFileSync(path.join(outputDir, "mcp-health.json"), "utf-8")
+    );
+    expect(Array.isArray(health.missing)).toBe(true);
+    expect(Array.isArray(health.ok)).toBe(true);
+    // secrets-scanner is a ref — should land in refs[]
+    expect(health.refs.some((r) => r.name === "secrets-scanner")).toBe(true);
+  });
+
+  it("generateAllAgents writes AGENT.md files with loadout-enriched frontmatter", async () => {
+    const { generateAllAgents } = await import("../agent-generator.mjs");
+    const outputDir = path.join(tmpDir, "agents");
+
+    const result = await generateAllAgents(LOADOUT_DEMO, outputDir, {
+      projectPath: tmpDir,
+    });
+    expect(result.success).toBe(true);
+    expect(result.roles.sort()).toEqual(
+      ["implementer", "planner", "reviewer"].sort()
+    );
+
+    // Reviewer — inline-extends security-auditor → rich frontmatter
+    const reviewerMd = fs.readFileSync(
+      path.join(outputDir, "reviewer", "AGENT.md"),
+      "utf-8"
+    );
+    const frontmatter = extractFrontmatter(reviewerMd);
+    expect(frontmatter.name).toBe("loadout-demo-reviewer");
+    expect(frontmatter.generated_by).toBe("claude-code-swarm");
+    expect(frontmatter.team_name).toBe("loadout-demo");
+    expect(frontmatter.role).toBe("reviewer");
+    expect(Array.isArray(frontmatter.mcpServers)).toBe(true);
+    expect(frontmatter.mcpServers).toContain("ast-grep");
+    expect(frontmatter.mcpServers).toContain("chrome-devtools");
+    // Hooks block should exist (chrome-devtools has a tools allowlist)
+    expect(frontmatter.hooks?.PreToolUse).toBeDefined();
+    expect(frontmatter.hooks.PreToolUse[0].matcher).toBe("mcp__.*");
+    // Capabilities flow through
+    expect(frontmatter.capabilities).toContain("task.update");
+
+    // Planner — no loadout → legacy minimal frontmatter
+    const plannerMd = fs.readFileSync(
+      path.join(outputDir, "planner", "AGENT.md"),
+      "utf-8"
+    );
+    expect(plannerMd).toContain("name: loadout-demo-planner");
+    // No mcpServers section since planner has no loadout
+    expect(plannerMd).not.toContain("mcpServers:");
+  });
+});
+
+function extractFrontmatter(agentMd) {
+  const match = agentMd.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  return yaml.load(match[1]);
+}

package/src/__tests__/fixtures/loadout-compile-team/loadouts/base-reviewer.yaml

@@ -0,0 +1,16 @@
+name: base-reviewer
+description: "Baseline reviewer loadout. Uses skill-tree's built-in code-review profile so the e2e test exercises the profile-resolution path."
+skills:
+  profile: code-review
+  max_tokens: 30000
+capabilities:
+  - file.read
+  - codebase.search
+permissions:
+  allow:
+    - "Read(**)"
+  deny:
+    - "Bash(git push:*)"
+prompt_addendum: |
+  ## Review Mindset
+  Cite line numbers; suggest, don't command.

package/src/__tests__/fixtures/loadout-compile-team/loadouts/extended-security.yaml

@@ -0,0 +1,10 @@
+name: extended-security
+description: "Security-focused extension of base-reviewer. Demonstrates extends: chain — child replaces skills.profile, inherits max_tokens + capabilities."
+extends: base-reviewer
+skills:
+  profile: security
+capabilities_add:
+  - exec.test
+permissions:
+  allow:
+    - "Bash(grep:*)"

package/src/__tests__/fixtures/loadout-compile-team/roles/auditor.yaml

@@ -0,0 +1,4 @@
+name: auditor
+display_name: Auditor
+description: "Security auditor role bound to the extended-security loadout (extends base-reviewer)."
+loadout: extended-security

package/src/__tests__/fixtures/loadout-compile-team/roles/inline-extender.yaml

@@ -0,0 +1,10 @@
+name: inline-extender
+display_name: Inline Extender
+description: "Role with an inline loadout that extends the named base-reviewer. Tests inline-extends resolution through compile."
+loadout:
+  extends: base-reviewer
+  capabilities_add:
+    - exec.run
+  prompt_addendum: |
+    ## Inline Mindset
+    Inherit base-reviewer; add execution capability.

package/src/__tests__/fixtures/loadout-compile-team/roles/reviewer.yaml

@@ -0,0 +1,4 @@
+name: reviewer
+display_name: Reviewer
+description: "Code reviewer role bound to the base-reviewer loadout."
+loadout: base-reviewer

package/src/__tests__/fixtures/loadout-compile-team/team.yaml

@@ -0,0 +1,15 @@
+name: loadout-compile-test
+description: "Fixture team for loadout-compile e2e tests. Roles bind to named loadouts that use built-in skill-tree profiles."
+version: 1
+roles:
+  - reviewer
+  - auditor
+  - inline-extender
+
+topology:
+  root:
+    role: reviewer
+  spawn_rules:
+    reviewer: [auditor, inline-extender]
+    auditor: []
+    inline-extender: []