agentopology 0.1.1 → 0.2.0

package/dist/import/__tests__/import.test.js

@@ -778,4 +778,558 @@ topology complex : [pipeline, fan-out] {
         expect(lead.outputs.confidence).toContain("high");
     });
 });
+// ===========================================================================
+// OpenClaw importer tests
+// ===========================================================================
+import { parseOpenClawJson, parseSoulMd, parseAgentsMd, parseSkillFile, parseMemoryMd, parseCronJobsJson, importOpenClaw, } from "../openclaw.js";
+// ---------------------------------------------------------------------------
+// OpenClaw test data
+// ---------------------------------------------------------------------------
+const OPENCLAW_JSON = `{
+  "agents": {
+    "defaults": {
+      "workspace": "~/.openclaw/workspace",
+      "model": { "primary": "openrouter/google/gemini-2.5-flash" }
+    },
+    "list": [
+      {
+        "id": "commander",
+        "name": "Commander",
+        "model": { "primary": "openrouter/google/gemini-2.5-flash" },
+        "workspace": "~/.openclaw/workspace-commander",
+        "agentDir": "~/.openclaw/config/agents/commander/agent",
+        "subagents": { "allowAgents": ["researcher", "worker"] }
+      },
+      {
+        "id": "researcher",
+        "name": "Researcher",
+        "model": {
+          "primary": "openrouter/google/gemini-2.5-flash",
+          "fallbacks": ["openrouter/google/gemini-2.5-flash-lite"]
+        },
+        "workspace": "~/.openclaw/workspace-researcher",
+        "agentDir": "~/.openclaw/config/agents/researcher/agent"
+      }
+    ]
+  },
+  "gateway": { "port": 18789, "auth": { "mode": "token", "token": "\${OPENCLAW_AUTH_TOKEN}" } },
+  "models": {
+    "providers": {
+      "openrouter": {
+        "apiKey": "\${OPENROUTER_API_KEY}",
+        "baseUrl": "https://openrouter.ai/api/v1",
+        "models": [
+          { "id": "openrouter/google/gemini-2.5-flash", "name": "Gemini 2.5 Flash" }
+        ]
+      }
+    }
+  },
+  "tools": { "allow": [], "deny": ["dangerous-tool"], "agentToAgent": { "enabled": true } },
+  "env": { "OPENROUTER_API_KEY": "\${OPENROUTER_API_KEY}", "MY_VAR": "hello" }
+}`;
+const SOUL_MD = `> A test topology for unit testing.
+
+## Identity
+- Name: Test Topology
+- Version: 2.0.0
+- Patterns: supervisor, fan-out
+
+## Mission
+A test topology for unit testing.
+
+## Roles
+### Strategy
+Plan and coordinate
+
+### Research
+Find information
+
+## Ethical Guardrails
+- Tool restrictions: none
+
+## Parameters
+
+- **campaign**: string (required)
+- **mode**: string = intelligence
+
+## Interface
+
+- Entry: commander
+- Exit: commander
+
+## Triggers
+
+### launch
+Pattern: \`/launch <CAMPAIGN>\`
+Argument: CAMPAIGN
+
+### status
+Pattern: \`/status <CAMPAIGN>\`
+Argument: CAMPAIGN
+
+## Environment
+
+- \`OPENROUTER_API_KEY\`: \${OPENROUTER_API_KEY}
+- \`MY_VAR\`: hello
+`;
+const AGENTS_MD = `# Sub-Agent Definitions
+
+## Pipeline Overview
+Test Topology uses a supervisor + fan-out topology.
+
+## Agents
+
+### Commander
+- **Model:** openrouter/google/gemini-2.5-flash
+- **Phase:** 1
+- **Role:** Plan and coordinate
+- **Tools allowed:** Read, Write, Bash
+- **Tools denied:** none
+- **Reads:** workspace
+- **Writes:** workspace
+- **Skills:** campaign-management
+- **Max turns:** 100
+
+#### Instructions
+
+You are the commander.
+
+Do important things.
+- **Maximum execution time:** 30m
+- **Retry:** max 2 attempts
+
+### Researcher
+- **Model:** openrouter/google/gemini-2.5-flash
+- **Phase:** 2
+- **Role:** Find information
+- **Tools allowed:** Read, Write
+- **Tools denied:** none
+- **Reads:** workspace, domains
+- **Writes:** workspace
+- **Rate limit:** 30/hour
+- **Circuit breaker:** threshold=5, window=30m, cooldown=1h
+- **On failure:** continue
+
+#### Instructions
+
+You are the researcher.
+- **Maximum execution time:** 45m
+- **Retry:** max 3 attempts
+
+## Group Chat Coordination
+
+### Strategy Session
+- **Members:** commander, researcher
+- **Speaker selection:** round-robin
+- **Max rounds:** 5
+- **Termination:** Commander confirms the plan
+- **Description:** Strategy planning session
+- **Timeout:** 30m
+
+## Flow
+
+### Execution Order
+1. commander -> strategy-session
+2. strategy-session -> researcher
+3. researcher -x-> commander (max 3 iterations)
+
+### Bounded Loops
+- researcher <-> commander: max 3 iterations (prevents infinite loops)
+
+### Error Handling
+- On error in researcher: route to commander
+
+## Gates
+
+### Quality Check
+- **After:** researcher
+- **Before:** commander
+- **On failure:** bounce-back
+- **Behavior:** blocking
+- **Checks:** output-valid, data-complete
+
+## Schedule
+
+### Morning Run
+- **Agent:** commander
+- **Cron:** \`0 9 * * 0-4\`
+- **Enabled:** true
+
+## Hooks
+
+### Block Destructive
+- **Event:** PreToolUse
+- **Run:** exit 2
+- **Type:** command
+
+### Log Completion
+- **Event:** AgentStop
+- **Run:** scripts/log.sh
+- **Type:** command
+
+---
+
+## Test Topology -- Topology Overview
+
+### Architecture
+- Patterns: supervisor, fan-out
+- Agents: 2
+- Gates: 1
+- Version: 2.0.0
+`;
+const SKILL_MD = `---
+name: campaign-management
+description: Manage campaigns end to end
+user-invocable: true
+---
+
+This skill manages campaign lifecycle.
+`;
+const MEMORY_MD = `# Memory Structure
+
+## Workspace
+- Path: \`campaigns/{CAMPAIGN}/\`
+- Structure: messages, outbox, logs
+
+## Domains
+- Path: \`campaigns/{CAMPAIGN}/intel/\`
+`;
+// ---------------------------------------------------------------------------
+// parseOpenClawJson
+// ---------------------------------------------------------------------------
+describe("parseOpenClawJson", () => {
+    it("extracts agent list with models", () => {
+        const result = parseOpenClawJson(OPENCLAW_JSON);
+        expect(result.agents).toHaveLength(2);
+        expect(result.agents[0].id).toBe("commander");
+        expect(result.agents[0].model).toBe("openrouter/google/gemini-2.5-flash");
+        expect(result.agents[0].subagents).toEqual(["researcher", "worker"]);
+    });
+    it("extracts fallback chains", () => {
+        const result = parseOpenClawJson(OPENCLAW_JSON);
+        expect(result.agents[1].fallbacks).toEqual(["openrouter/google/gemini-2.5-flash-lite"]);
+    });
+    it("extracts providers", () => {
+        const result = parseOpenClawJson(OPENCLAW_JSON);
+        expect(result.providers).toHaveLength(1);
+        expect(result.providers[0].name).toBe("openrouter");
+        expect(result.providers[0].apiKey).toBe("${OPENROUTER_API_KEY}");
+        expect(result.providers[0].baseUrl).toBe("https://openrouter.ai/api/v1");
+        expect(result.providerNames).toEqual(["openrouter"]);
+    });
+    it("extracts tools settings and env", () => {
+        const result = parseOpenClawJson(OPENCLAW_JSON);
+        expect(result.settings.deny).toEqual(["dangerous-tool"]);
+        expect(result.env.MY_VAR).toBe("hello");
+    });
+    it("extracts gateway extensions", () => {
+        const result = parseOpenClawJson(OPENCLAW_JSON);
+        expect(result.extensions["gateway-port"]).toBe(18789);
+        expect(result.extensions["auth-mode"]).toBe("token");
+    });
+});
+// ---------------------------------------------------------------------------
+// parseSoulMd
+// ---------------------------------------------------------------------------
+describe("parseSoulMd", () => {
+    it("extracts identity", () => {
+        const result = parseSoulMd(SOUL_MD);
+        expect(result.name).toBe("test-topology");
+        expect(result.version).toBe("2.0.0");
+        expect(result.patterns).toEqual(["supervisor", "fan-out"]);
+    });
+    it("extracts description from quote block", () => {
+        const result = parseSoulMd(SOUL_MD);
+        expect(result.description).toBe("A test topology for unit testing.");
+    });
+    it("extracts roles", () => {
+        const result = parseSoulMd(SOUL_MD);
+        expect(result.roles.strategy).toBe("Plan and coordinate");
+        expect(result.roles.research).toBe("Find information");
+    });
+    it("extracts parameters", () => {
+        const result = parseSoulMd(SOUL_MD);
+        expect(result.params).toHaveLength(2);
+        expect(result.params[0]).toEqual({ name: "campaign", type: "string", default: undefined, required: true });
+        expect(result.params[1]).toEqual({ name: "mode", type: "string", default: "intelligence", required: false });
+    });
+    it("extracts interface endpoints", () => {
+        const result = parseSoulMd(SOUL_MD);
+        expect(result.interfaceEndpoints).toEqual({ entry: "commander", exit: "commander" });
+    });
+    it("extracts triggers", () => {
+        const result = parseSoulMd(SOUL_MD);
+        expect(result.triggers).toHaveLength(2);
+        expect(result.triggers[0]).toEqual({ name: "launch", pattern: "/launch <CAMPAIGN>", argument: "CAMPAIGN" });
+        expect(result.triggers[1]).toEqual({ name: "status", pattern: "/status <CAMPAIGN>", argument: "CAMPAIGN" });
+    });
+    it("extracts environment variables", () => {
+        const result = parseSoulMd(SOUL_MD);
+        expect(result.env["OPENROUTER_API_KEY"]).toBe("${OPENROUTER_API_KEY}");
+        expect(result.env["MY_VAR"]).toBe("hello");
+    });
+});
+// ---------------------------------------------------------------------------
+// parseAgentsMd
+// ---------------------------------------------------------------------------
+describe("parseAgentsMd", () => {
+    it("extracts agents with basic properties", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        expect(result.agents).toHaveLength(2);
+        const cmd = result.agents[0];
+        expect(cmd.id).toBe("commander");
+        expect(cmd.phase).toBe(1);
+        expect(cmd.tools).toEqual(["Read", "Write", "Bash"]);
+        expect(cmd.reads).toEqual(["workspace"]);
+        expect(cmd.writes).toEqual(["workspace"]);
+        expect(cmd.skills).toEqual(["campaign-management"]);
+        expect(cmd.maxTurns).toBe(100);
+    });
+    it("extracts agent prompt (instructions)", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        const cmd = result.agents[0];
+        expect(cmd.prompt).toContain("You are the commander.");
+        expect(cmd.prompt).toContain("Do important things.");
+    });
+    it("extracts trailing properties after instructions", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        const cmd = result.agents[0];
+        expect(cmd.timeout).toBe("30m");
+        expect(cmd.retry).toBe(2);
+    });
+    it("extracts rate limit and circuit breaker", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        const researcher = result.agents[1];
+        expect(researcher.rateLimit).toBe("30/hour");
+        expect(researcher.circuitBreaker).toEqual({
+            threshold: 5,
+            window: "30m",
+            cooldown: "1h",
+        });
+        expect(researcher.onFail).toBe("continue");
+    });
+    it("extracts group chat", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        expect(result.groups).toHaveLength(1);
+        const group = result.groups[0];
+        expect(group.id).toBe("strategy-session");
+        expect(group.members).toEqual(["commander", "researcher"]);
+        expect(group.speakerSelection).toBe("round-robin");
+        expect(group.maxRounds).toBe(5);
+        expect(group.termination).toBe("Commander confirms the plan");
+        expect(group.timeout).toBe("30m");
+    });
+    it("extracts flow edges including error edges", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        expect(result.edges).toHaveLength(3);
+        expect(result.edges[0]).toMatchObject({ from: "commander", to: "strategy-session" });
+        expect(result.edges[0].isError).toBeUndefined();
+        expect(result.edges[1]).toMatchObject({ from: "strategy-session", to: "researcher" });
+        expect(result.edges[1].isError).toBeUndefined();
+        expect(result.edges[2]).toMatchObject({ from: "researcher", to: "commander", isError: true, maxIterations: 3 });
+    });
+    it("extracts gates", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        expect(result.gates).toHaveLength(1);
+        const gate = result.gates[0];
+        expect(gate.id).toBe("quality-check");
+        expect(gate.after).toBe("researcher");
+        expect(gate.before).toBe("commander");
+        expect(gate.onFail).toBe("bounce-back");
+        expect(gate.behavior).toBe("blocking");
+        expect(gate.checks).toEqual(["output-valid", "data-complete"]);
+    });
+    it("extracts schedule", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        expect(result.schedules).toHaveLength(1);
+        expect(result.schedules[0]).toEqual({
+            id: "morning-run",
+            agent: "commander",
+            cron: "0 9 * * 0-4",
+            enabled: true,
+        });
+    });
+    it("extracts hooks", () => {
+        const result = parseAgentsMd(AGENTS_MD);
+        expect(result.hooks).toHaveLength(2);
+        expect(result.hooks[0].name).toBe("block-destructive");
+        expect(result.hooks[0].on).toBe("PreToolUse");
+        expect(result.hooks[0].run).toBe("exit 2");
+        expect(result.hooks[1].name).toBe("log-completion");
+        expect(result.hooks[1].on).toBe("AgentStop");
+    });
+});
+// ---------------------------------------------------------------------------
+// parseSkillFile
+// ---------------------------------------------------------------------------
+describe("parseSkillFile (openclaw)", () => {
+    it("extracts skill from frontmatter", () => {
+        const skill = parseSkillFile("campaign-management", SKILL_MD);
+        expect(skill.id).toBe("campaign-management");
+        expect(skill.description).toBe("Manage campaigns end to end");
+        expect(skill.userInvocable).toBe(true);
+    });
+    it("handles skill without frontmatter", () => {
+        const skill = parseSkillFile("my-skill", "This skill does things.");
+        expect(skill.id).toBe("my-skill");
+        expect(skill.description).toBe("This skill does things.");
+        expect(skill.userInvocable).toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// parseMemoryMd
+// ---------------------------------------------------------------------------
+describe("parseMemoryMd", () => {
+    it("extracts workspace and domains", () => {
+        const result = parseMemoryMd(MEMORY_MD);
+        const ws = result.memory.workspace;
+        expect(ws.path).toBe("campaigns/{CAMPAIGN}/");
+        expect(ws.structure).toEqual(["messages", "outbox", "logs"]);
+        const domains = result.memory.domains;
+        expect(domains.path).toBe("campaigns/{CAMPAIGN}/intel/");
+    });
+});
+// ---------------------------------------------------------------------------
+// parseCronJobsJson
+// ---------------------------------------------------------------------------
+describe("parseCronJobsJson", () => {
+    it("parses cron jobs array", () => {
+        const json = JSON.stringify({
+            jobs: [
+                { id: "morning", agentId: "commander", schedule: { expr: "0 9 * * *" }, enabled: true },
+                { id: "evening", agentId: "reporter", cron: "0 18 * * *", enabled: false },
+            ],
+        });
+        const jobs = parseCronJobsJson(json);
+        expect(jobs).toHaveLength(2);
+        expect(jobs[0]).toEqual({ id: "morning", agent: "commander", cron: "0 9 * * *", enabled: true });
+        expect(jobs[1]).toEqual({ id: "evening", agent: "reporter", cron: "0 18 * * *", enabled: false });
+    });
+});
+// ---------------------------------------------------------------------------
+// importOpenClaw (integration)
+// ---------------------------------------------------------------------------
+describe("importOpenClaw", () => {
+    const minimalFiles = [
+        { path: "openclaw.json", content: OPENCLAW_JSON },
+        { path: "SOUL.md", content: SOUL_MD },
+        { path: "AGENTS.md", content: AGENTS_MD },
+        { path: "MEMORY.md", content: MEMORY_MD },
+        { path: "skills/campaign-management/SKILL.md", content: SKILL_MD },
+    ];
+    it("produces a complete TopologyAST", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        expect(ast.topology.name).toBe("test-topology");
+        expect(ast.topology.version).toBe("2.0.0");
+        expect(ast.topology.patterns).toEqual(["supervisor", "fan-out"]);
+        expect(ast.topology.description).toBe("A test topology for unit testing.");
+    });
+    it("imports agents with reverse-mapped models", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        const agents = ast.nodes.filter((n) => n.type === "agent");
+        expect(agents).toHaveLength(2);
+        const cmd = agents.find((a) => a.id === "commander");
+        expect(cmd.model).toBe("google/gemini-2.5-flash");
+        expect(cmd.phase).toBe(1);
+        expect(cmd.timeout).toBe("30m");
+        const researcher = agents.find((a) => a.id === "researcher");
+        expect(researcher.model).toBe("google/gemini-2.5-flash");
+        expect(researcher.fallbackChain).toEqual(["google/gemini-2.5-flash-lite"]);
+    });
+    it("imports roles, matching agents to role keys", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        expect(ast.roles.strategy).toBe("Plan and coordinate");
+        expect(ast.roles.research).toBe("Find information");
+        const cmd = ast.nodes.find((n) => n.id === "commander");
+        expect(cmd.role).toBe("strategy");
+    });
+    it("imports groups, gates, edges, hooks, schedules", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        const groups = ast.nodes.filter((n) => n.type === "group");
+        expect(groups).toHaveLength(1);
+        const gates = ast.nodes.filter((n) => n.type === "gate");
+        expect(gates).toHaveLength(1);
+        expect(ast.edges).toHaveLength(3);
+        expect(ast.hooks).toHaveLength(2);
+        expect(ast.schedules).toHaveLength(1);
+    });
+    it("imports skills", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        expect(ast.skills).toHaveLength(1);
+        expect(ast.skills[0].id).toBe("campaign-management");
+        expect(ast.skills[0].userInvocable).toBe(true);
+    });
+    it("imports params, triggers, interface endpoints", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        expect(ast.params).toHaveLength(2);
+        expect(ast.triggers).toHaveLength(2);
+        expect(ast.interfaceEndpoints).toEqual({ entry: "commander", exit: "commander" });
+    });
+    it("imports providers with reverse-mapped models", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        expect(ast.providers).toHaveLength(1);
+        expect(ast.providers[0].name).toBe("openrouter");
+        expect(ast.providers[0].default).toBe(true);
+    });
+    it("imports env and settings", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        expect(ast.env["MY_VAR"]).toBe("hello");
+        expect(ast.settings.deny).toEqual(["dangerous-tool"]);
+    });
+    it("imports memory", () => {
+        const ast = importOpenClaw(minimalFiles, "test-topology");
+        expect(ast.memory.workspace?.path).toBe("campaigns/{CAMPAIGN}/");
+    });
+});
+// ---------------------------------------------------------------------------
+// importFromPlatform — OpenClaw dispatch
+// ---------------------------------------------------------------------------
+describe("importFromPlatform (openclaw)", () => {
+    it("dispatches to openclaw", () => {
+        const files = [
+            { path: "openclaw.json", content: OPENCLAW_JSON },
+            { path: "SOUL.md", content: SOUL_MD },
+            { path: "AGENTS.md", content: AGENTS_MD },
+        ];
+        const atSource = importFromPlatform(files, "openclaw", "test");
+        // SOUL.md Identity overrides the topologyName param
+        expect(atSource).toContain("topology test-topology");
+        expect(atSource).toContain("agent commander");
+        expect(atSource).toContain("agent researcher");
+    });
+    it("falls back to topologyName when SOUL.md is missing", () => {
+        const files = [
+            { path: "openclaw.json", content: OPENCLAW_JSON },
+            { path: "AGENTS.md", content: AGENTS_MD },
+        ];
+        const atSource = importFromPlatform(files, "openclaw", "my-project");
+        expect(atSource).toContain("topology my-project");
+    });
+    it("generates parseable .at output", () => {
+        const files = [
+            { path: "openclaw.json", content: OPENCLAW_JSON },
+            { path: "SOUL.md", content: SOUL_MD },
+            { path: "AGENTS.md", content: AGENTS_MD },
+            { path: "MEMORY.md", content: MEMORY_MD },
+            { path: "skills/campaign-management/SKILL.md", content: SKILL_MD },
+        ];
+        const atSource = importFromPlatform(files, "openclaw", "test");
+        const ast = parse(atSource);
+        expect(ast.topology.name).toBe("test-topology");
+        expect(ast.nodes.filter((n) => n.type === "agent").length).toBe(2);
+    });
+    it("validates with zero errors (warnings allowed)", () => {
+        const files = [
+            { path: "openclaw.json", content: OPENCLAW_JSON },
+            { path: "SOUL.md", content: SOUL_MD },
+            { path: "AGENTS.md", content: AGENTS_MD },
+            { path: "MEMORY.md", content: MEMORY_MD },
+            { path: "skills/campaign-management/SKILL.md", content: SKILL_MD },
+        ];
+        const atSource = importFromPlatform(files, "openclaw", "test");
+        const ast = parse(atSource);
+        const errors = validate(ast).filter((e) => e.level === "error");
+        expect(errors).toEqual([]);
+    });
+});
 //# sourceMappingURL=import.test.js.map