agentopology 0.9.2 → 0.10.0

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

@@ -796,558 +796,4 @@ 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