npm - claude-cwc - Versions diffs - 0.2.0 - Mend

claude-cwc 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/LICENSE +21 -0
package/README.md +218 -0
package/dist/bin/cwc.js +82 -0
package/dist/client/assets/index-BtCVmYEx.css +1 -0
package/dist/client/assets/index-BygZUlo1.js +77 -0
package/dist/client/index.html +17 -0
package/dist/src/bfs.js +42 -0
package/dist/src/conflict-detector.js +24 -0
package/dist/src/exporter.js +139 -0
package/dist/src/file-writer.js +53 -0
package/dist/src/index.js +2 -0
package/dist/src/prose-generator.js +128 -0
package/dist/src/schema.js +1 -0
package/dist/src/server/api/agents.js +47 -0
package/dist/src/server/api/claude-check.js +18 -0
package/dist/src/server/api/export-delete.js +87 -0
package/dist/src/server/api/export-preview.js +71 -0
package/dist/src/server/api/export.js +23 -0
package/dist/src/server/api/exported-workflows.js +53 -0
package/dist/src/server/api/file-content.js +31 -0
package/dist/src/server/api/health.js +8 -0
package/dist/src/server/api/open-file.js +32 -0
package/dist/src/server/api/recents.js +40 -0
package/dist/src/server/api/skills.js +55 -0
package/dist/src/server/api/workflows.js +107 -0
package/dist/src/server/index.js +59 -0
package/dist/src/server/start.js +6 -0
package/dist/src/skill-resolver.js +52 -0
package/dist/src/slugify.js +9 -0
package/package.json +51 -0

package/dist/client/index.html ADDED Viewed

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Claude Workflow Composer</title>
+    <meta name="description" content="Visually compose multi-agent coding workflows for Claude Code. Drag agents, attach skills, wire handoffs, and export." />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=Spline+Sans:wght@400;500;600;700&family=Barlow:wght@500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
+    <script type="module" crossorigin src="/assets/index-BygZUlo1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BtCVmYEx.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/src/bfs.js ADDED Viewed

@@ -0,0 +1,42 @@
+export function bfsTraversal(nodes, edges) {
+    const nodeMap = new Map(nodes.map(n => [n.id, n]));
+    // Build adjacency: from → edges
+    const adj = new Map();
+    for (const e of edges) {
+        if (!adj.has(e.from))
+            adj.set(e.from, []);
+        adj.get(e.from).push(e);
+    }
+    // Entry nodes: nodes with no incoming edges (ignoring terminal edges where to === null)
+    const hasIncoming = new Set(edges.filter(e => e.to !== null).map(e => e.to));
+    let entryIds = nodes.filter(n => !hasIncoming.has(n.id)).map(n => n.id);
+    // If every node has incoming edges (pure cycle), seed with the first node
+    if (entryIds.length === 0 && nodes.length > 0) {
+        entryIds = [nodes[0].id];
+    }
+    const visited = new Set();
+    const steps = [];
+    // Queue of [nodeId, level]
+    const queue = entryIds.map(id => [id, 0]);
+    while (queue.length > 0) {
+        const [id, level] = queue.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        const n = nodeMap.get(id);
+        if (!n)
+            continue;
+        const rawEdges = adj.get(id) ?? [];
+        const annotated = rawEdges.map(e => ({
+            edge: e,
+            isBackEdge: e.to !== null && visited.has(e.to),
+        }));
+        steps.push({ node: n, level, outgoingEdges: annotated });
+        for (const ae of annotated) {
+            if (!ae.isBackEdge && ae.edge.to !== null) {
+                queue.push([ae.edge.to, level + 1]);
+            }
+        }
+    }
+    return steps;
+}

package/dist/src/conflict-detector.js ADDED Viewed

@@ -0,0 +1,24 @@
+export function detectConflict(fileContent, ownershipRegex, currentWorkflowId) {
+    const lines = fileContent.split('\n');
+    // Scan upward for first non-blank line
+    let lastNonBlank = null;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const trimmed = lines[i].trim();
+        if (trimmed.length > 0) {
+            lastNonBlank = trimmed;
+            break;
+        }
+    }
+    if (lastNonBlank === null)
+        return 'absent';
+    if (!lastNonBlank.startsWith('<!-- cwc:'))
+        return 'absent';
+    if (!ownershipRegex.test(lastNonBlank))
+        return 'malformed';
+    // Extract UUID — last token before ' -->'
+    const uuidMatch = lastNonBlank.match(/([^\s:>]+) -->$/);
+    if (!uuidMatch)
+        return 'malformed';
+    const foundId = uuidMatch[1];
+    return foundId === currentWorkflowId ? 'owned' : 'foreign';
+}

package/dist/src/exporter.js ADDED Viewed

@@ -0,0 +1,139 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import matter from 'gray-matter';
+import { slugify } from './slugify.js';
+import { generateOrchestratorBody } from './prose-generator.js';
+import { resolveSkill } from './skill-resolver.js';
+import { buildAgentFileContent, buildWorkflowSkillContent } from './file-writer.js';
+import { detectConflict } from './conflict-detector.js';
+const AGENT_OWNERSHIP_REGEX = /^<!-- cwc:node:[^:\s]+:workflow:[^:\s>]+ -->$/;
+const WORKFLOW_OWNERSHIP_REGEX = /^<!-- cwc:workflow:[^:\s>]+ -->$/;
+async function safeReadFile(p) {
+    try {
+        return await fs.readFile(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+async function ensureDir(p) {
+    await fs.mkdir(p, { recursive: true });
+}
+async function resolveSkillWithOverride(slug, userSkillsDir) {
+    if (!slug.includes(':') && userSkillsDir) {
+        const skillMdPath = path.join(userSkillsDir, slug, 'SKILL.md');
+        try {
+            const content = await fs.readFile(skillMdPath, 'utf-8');
+            const { data } = matter(content);
+            return { slug, description: typeof data.description === 'string' ? data.description : null, found: true };
+        }
+        catch {
+            // Fall through to normal resolution
+        }
+    }
+    return resolveSkill(slug);
+}
+export async function exportWorkflow(cwc, target, opts) {
+    const warnings = [];
+    const workflowId = cwc.meta.id;
+    const workflowSlug = 'cwc-' + slugify(cwc.meta.name);
+    const agentsDir = target.type === 'project'
+        ? path.join(target.projectDir, '.claude', 'agents')
+        : path.join(target.userDir ?? (process.env.HOME ?? ''), '.claude', 'agents');
+    await ensureDir(agentsDir);
+    const updatedNodes = [];
+    const nodeOverrides = {};
+    for (const node of cwc.nodes) {
+        if (node.agentRef) {
+            // Ref node — points to an existing agent; don't write a new file
+            const refSlug = node.agentRef;
+            if (node.exportedSlug && node.exportedSlug !== refSlug) {
+                const oldPath = path.join(agentsDir, `${node.exportedSlug}.md`);
+                const oldContent = await safeReadFile(oldPath);
+                if (oldContent !== null) {
+                    const status = detectConflict(oldContent, AGENT_OWNERSHIP_REGEX, workflowId);
+                    if (status === 'owned') {
+                        await fs.unlink(oldPath);
+                    }
+                }
+            }
+            // Resolve ref node's skills for warnings
+            for (const skillSlug of node.agent.skills ?? []) {
+                const resolved = await resolveSkillWithOverride(skillSlug, opts.userSkillsDir);
+                if (!resolved.found) {
+                    warnings.push(`Skill not found: ${skillSlug} — install it on the target machine`);
+                }
+            }
+            // Collect overrides for orchestrator annotation
+            const hasOverrides = (node.agent.skills ?? []).length > 0
+                || (node.agent.tools ?? []).length > 0
+                || (node.agent.systemPrompt ?? '').trim().length > 0
+                || (node.agent.completionCriteria ?? '').trim().length > 0;
+            if (hasOverrides) {
+                nodeOverrides[node.id] = {
+                    skills: node.agent.skills,
+                    tools: node.agent.tools,
+                    systemPrompt: node.agent.systemPrompt,
+                    completionCriteria: node.agent.completionCriteria,
+                };
+            }
+            // Warn if the referenced agent file doesn't exist on the target machine
+            const refPath = path.join(agentsDir, `${refSlug}.md`);
+            const refContent = await safeReadFile(refPath);
+            if (refContent === null) {
+                warnings.push(`Referenced agent not found: ${refSlug} — install it on the target machine`);
+            }
+            updatedNodes.push({ ...node, exportedSlug: refSlug });
+            continue;
+        }
+        const newSlug = slugify(node.agent.name);
+        const agentPath = path.join(agentsDir, `${newSlug}.md`);
+        // Rename: old file cleanup
+        if (node.exportedSlug && node.exportedSlug !== newSlug) {
+            const oldPath = path.join(agentsDir, `${node.exportedSlug}.md`);
+            const oldContent = await safeReadFile(oldPath);
+            if (oldContent !== null) {
+                const status = detectConflict(oldContent, AGENT_OWNERSHIP_REGEX, workflowId);
+                if (status === 'owned') {
+                    await fs.unlink(oldPath);
+                }
+            }
+            // If file missing (null): skip delete, proceed to write new file
+        }
+        // Resolve skills
+        const resolvedSkills = [];
+        for (const skillSlug of node.agent.skills ?? []) {
+            const resolved = await resolveSkillWithOverride(skillSlug, opts.userSkillsDir);
+            if (!resolved.found) {
+                warnings.push(`Skill not found: ${skillSlug} — install it on the target machine`);
+            }
+            resolvedSkills.push(resolved);
+        }
+        const content = buildAgentFileContent(node, resolvedSkills, workflowId);
+        await fs.writeFile(agentPath, content, 'utf-8');
+        updatedNodes.push({ ...node, exportedSlug: newSlug });
+    }
+    // Generate workflow skill
+    const orchestratorBody = generateOrchestratorBody(cwc.nodes, cwc.edges, cwc.meta.name, nodeOverrides);
+    const skillContent = buildWorkflowSkillContent(cwc.meta.name, cwc.meta.description, orchestratorBody, workflowId);
+    const skillDir = path.join(opts.skillsDir, workflowSlug);
+    await ensureDir(skillDir);
+    const skillFilePath = path.join(skillDir, 'SKILL.md');
+    const existingSkill = await safeReadFile(skillFilePath);
+    if (existingSkill !== null) {
+        const status = detectConflict(existingSkill, WORKFLOW_OWNERSHIP_REGEX, workflowId);
+        if (status === 'foreign') {
+            warnings.push(`Workflow skill at ${skillFilePath} belongs to a different workflow — overwriting`);
+        }
+        else if (status === 'absent') {
+            warnings.push(`Workflow skill at ${skillFilePath} was not created by this workflow — overwriting`);
+        }
+    }
+    await fs.writeFile(skillFilePath, skillContent, 'utf-8');
+    const updatedCwc = {
+        ...cwc,
+        nodes: updatedNodes,
+        meta: { ...cwc.meta, updated: new Date().toISOString() },
+    };
+    return { updatedCwc, warnings };
+}

package/dist/src/file-writer.js ADDED Viewed

@@ -0,0 +1,53 @@
+function buildFrontmatter(node) {
+    const { name, description, color, model, tools } = node.agent;
+    const lines = ['---'];
+    lines.push(`name: ${name}`);
+    lines.push(`description: ${description}`);
+    if (color)
+        lines.push(`color: ${color}`);
+    if (model)
+        lines.push(`model: ${model}`);
+    if (tools && tools.length > 0)
+        lines.push(`tools: ${tools.join(', ')}`);
+    lines.push('---');
+    return lines.join('\n');
+}
+function buildSkillsBlock(skills) {
+    const lines = skills.map(s => s.description
+        ? `Use the \`${s.slug}\` skill. (${s.description})`
+        : `Use the \`${s.slug}\` skill.`);
+    return `## Workflow Skills\n\n${lines.join('\n')}`;
+}
+export function buildAgentFileContent(node, resolvedSkills, workflowId) {
+    const parts = [];
+    parts.push(buildFrontmatter(node));
+    const { systemPrompt, completionCriteria } = node.agent;
+    if (systemPrompt && systemPrompt.trim().length > 0) {
+        parts.push('\n' + systemPrompt);
+    }
+    if (completionCriteria && completionCriteria.trim().length > 0) {
+        parts.push(`\n\n## Completion Criteria\n\nBefore returning, verify: ${completionCriteria}`);
+    }
+    const ownershipComment = `<!-- cwc:node:${node.id}:workflow:${workflowId} -->`;
+    const hasContent = (systemPrompt && systemPrompt.trim().length > 0) ||
+        (completionCriteria && completionCriteria.trim().length > 0);
+    if (resolvedSkills.length > 0) {
+        const separator = hasContent ? '\n\n---\n' : '\n';
+        parts.push(separator + buildSkillsBlock(resolvedSkills));
+        parts.push('\n' + ownershipComment);
+    }
+    else {
+        parts.push('\n' + ownershipComment);
+    }
+    return parts.join('');
+}
+export function buildWorkflowSkillContent(name, description, orchestratorBody, workflowId) {
+    const frontmatter = [
+        '---',
+        `name: ${name}`,
+        `description: ${description}`,
+        'disable-model-invocation: true',
+        '---',
+    ].join('\n');
+    return `${frontmatter}\n\n${orchestratorBody}\n<!-- cwc:workflow:${workflowId} -->`;
+}

package/dist/src/index.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ // Entry point - will be populated in next tasks

package/dist/src/prose-generator.js ADDED Viewed

@@ -0,0 +1,128 @@
+import { bfsTraversal } from './bfs.js';
+import { slugify } from './slugify.js';
+function oxfordJoin(items) {
+    if (items.length === 0)
+        return '';
+    if (items.length === 1)
+        return items[0];
+    if (items.length === 2)
+        return `${items[0]} and ${items[1]}`;
+    return `${items.slice(0, -1).join(', ')}, and ${items[items.length - 1]}`;
+}
+function formatArtifactLabel(a) {
+    return a.type === 'file' && a.path ? `${a.name} (\`${a.path}\`)` : a.name;
+}
+function boldWrapAgentNames(text, agentNames) {
+    let result = text;
+    for (const name of [...agentNames].sort((a, b) => b.length - a.length)) {
+        result = result.replaceAll(name, `**${name}**`);
+    }
+    return result;
+}
+function formatContextClause(context) {
+    if (!context || context.length === 0)
+        return '';
+    return ` Pass the ${oxfordJoin(context.map(formatArtifactLabel))} forward.`;
+}
+function nodeSlug(node) {
+    return node.agentRef ?? node.exportedSlug ?? slugify(node.agent.name);
+}
+function formatOverrideAnnotation(nodeId, overrides) {
+    const o = overrides[nodeId];
+    if (!o)
+        return '';
+    const parts = [];
+    if (o.skills && o.skills.length > 0)
+        parts.push(`additional skills (${o.skills.join(', ')})`);
+    if (o.tools && o.tools.length > 0)
+        parts.push(`tools (${o.tools.join(', ')})`);
+    if (o.systemPrompt && o.systemPrompt.trim()) {
+        const snippet = o.systemPrompt.trim().slice(0, 80);
+        parts.push(`prompt "${snippet}${o.systemPrompt.length > 80 ? '...' : ''}"`);
+    }
+    if (o.completionCriteria && o.completionCriteria.trim()) {
+        const snippet = o.completionCriteria.trim().slice(0, 80);
+        parts.push(`completion "${snippet}${o.completionCriteria.length > 80 ? '...' : ''}"`);
+    }
+    if (parts.length === 0)
+        return '';
+    return ` Workflow-specific configuration: ${parts.join(', ')}.`;
+}
+export function generateOrchestratorBody(nodes, edges, workflowName, nodeOverrides = {}) {
+    const agentNames = nodes.map(n => n.agent.name);
+    const nodeMap = new Map(nodes.map(n => [n.id, n]));
+    const steps = bfsTraversal(nodes, edges);
+    const lines = [];
+    lines.push(`I am the orchestrator for the **${workflowName}** workflow. I coordinate this pipeline exclusively through the Agent tool — I do not read, write, or edit files myself. All implementation work is delegated to subagents.`, '', '## Pipeline', '');
+    let stepNum = 1;
+    const level0 = steps.filter(s => s.level === 0);
+    if (level0.length > 1) {
+        const nameList = level0.map(s => `**${s.node.agent.name}**`).join(' and ');
+        lines.push(`${stepNum++}. Invoke ${nameList} in parallel:`);
+        for (const s of level0) {
+            const trigger = s.node.startTrigger ? ` ${s.node.startTrigger}` : '';
+            const overrides = formatOverrideAnnotation(s.node.id, nodeOverrides);
+            lines.push(`   - **${s.node.agent.name}** (\`subagent_type: "${nodeSlug(s.node)}"\`)${trigger}.${overrides}`);
+        }
+    }
+    else if (level0.length === 1) {
+        const s = level0[0];
+        const trigger = s.node.startTrigger ? ` ${s.node.startTrigger}` : '';
+        const overrides = formatOverrideAnnotation(s.node.id, nodeOverrides);
+        lines.push(`${stepNum++}. Invoke **${s.node.agent.name}** (\`subagent_type: "${nodeSlug(s.node)}"\`)${trigger}.${overrides}`);
+    }
+    const emitted = new Set();
+    for (const step of steps) {
+        const forwardEdges = step.outgoingEdges.filter(ae => !ae.isBackEdge && ae.edge.to !== null);
+        const terminalEdges = step.outgoingEdges.filter(ae => ae.edge.to === null);
+        const backEdges = step.outgoingEdges.filter(ae => ae.isBackEdge);
+        if (forwardEdges.length > 1) {
+            const targets = forwardEdges.map(ae => nodeMap.get(ae.edge.to)).filter(Boolean);
+            const nameList = targets.map(n => `**${n.agent.name}**`).join(' and ');
+            lines.push(`${stepNum++}. When **${step.node.agent.name}** completes, invoke ${nameList} in parallel:`);
+            for (const ae of forwardEdges) {
+                const target = nodeMap.get(ae.edge.to);
+                if (!target)
+                    continue;
+                const trigger = ae.edge.trigger.trim() || `Activate **${target.agent.name}**.`;
+                const ctx = formatContextClause(ae.edge.context);
+                const overrides = formatOverrideAnnotation(ae.edge.to, nodeOverrides);
+                lines.push(`   - **${target.agent.name}** (\`subagent_type: "${nodeSlug(target)}"\`): ${trigger}${ctx}${overrides}`);
+                emitted.add(ae.edge.id);
+            }
+        }
+        else if (forwardEdges.length === 1) {
+            const ae = forwardEdges[0];
+            if (!emitted.has(ae.edge.id)) {
+                const target = nodeMap.get(ae.edge.to);
+                if (target) {
+                    const raw = ae.edge.trigger.trim() || `Invoke **${target.agent.name}**.`;
+                    const trigger = boldWrapAgentNames(raw, agentNames);
+                    const ctx = formatContextClause(ae.edge.context);
+                    const overrides = formatOverrideAnnotation(ae.edge.to, nodeOverrides);
+                    lines.push(`${stepNum++}. ${trigger} Use the Agent tool with \`subagent_type: "${nodeSlug(target)}"\`.${ctx}${overrides}`);
+                }
+                emitted.add(ae.edge.id);
+            }
+        }
+        for (const ae of terminalEdges) {
+            if (!emitted.has(ae.edge.id)) {
+                const raw = ae.edge.trigger.trim() || `**${step.node.agent.name}** completes the workflow.`;
+                lines.push(`${stepNum++}. ${boldWrapAgentNames(raw, agentNames)}`);
+                emitted.add(ae.edge.id);
+            }
+        }
+        for (const ae of backEdges) {
+            if (!emitted.has(ae.edge.id)) {
+                const target = nodeMap.get(ae.edge.to);
+                const raw = ae.edge.trigger.trim() || (target ? `Return to **${target.agent.name}**.` : '');
+                const trigger = boldWrapAgentNames(raw, agentNames);
+                const ctx = formatContextClause(ae.edge.context);
+                lines.push(`${stepNum++}. ${trigger}${ctx}`);
+                emitted.add(ae.edge.id);
+            }
+        }
+    }
+    lines.push('', '## Scope Boundary', '', 'Append the following to every subagent prompt:', '', '> Operate within the scope defined in this prompt. Escalate if the required work falls outside that scope.', '', '## Escalation', '', 'After every subagent returns, check its response. If `status` is `blocked` or `escalation_needed`, stop immediately and present the issue to the user — do not attempt to work around it.', '', '## Completion', '', 'When all steps finish, present a summary to the user: which agents ran, what each produced, and any escalations or skipped steps.');
+    return lines.join('\n');
+}

package/dist/src/schema.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/src/server/api/agents.js ADDED Viewed

@@ -0,0 +1,47 @@
+import { Router as createRouter } from 'express';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import matter from 'gray-matter';
+async function scanAgentsDir(dir, source) {
+    try {
+        const files = await fs.readdir(dir);
+        const results = await Promise.all(files
+            .filter((f) => f.endsWith('.md'))
+            .map(async (f) => {
+            const fullPath = path.join(dir, f);
+            try {
+                const raw = await fs.readFile(fullPath, 'utf-8');
+                const { data } = matter(raw);
+                if (!data['name'])
+                    return null;
+                return {
+                    name: String(data['name']),
+                    description: String(data['description'] ?? ''),
+                    slug: f.replace(/\.md$/, ''),
+                    source,
+                    filePath: fullPath,
+                };
+            }
+            catch {
+                return null;
+            }
+        }));
+        return results.filter((r) => r !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export function agentsRouter(userHomeDir) {
+    const router = createRouter();
+    router.get('/', async (req, res) => {
+        const projectDir = req.query['projectDir'];
+        const userAgentsDir = path.join(userHomeDir, '.claude', 'agents');
+        const agents = [
+            ...await scanAgentsDir(userAgentsDir, 'user'),
+            ...(projectDir ? await scanAgentsDir(path.join(projectDir, '.claude', 'agents'), 'project') : []),
+        ];
+        res.json(agents);
+    });
+    return router;
+}

package/dist/src/server/api/claude-check.js ADDED Viewed

@@ -0,0 +1,18 @@
+import { Router as createRouter } from 'express';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+export function claudeCheckRouter() {
+    const router = createRouter();
+    router.get('/', async (_req, res) => {
+        const claudeDir = path.join(os.homedir(), '.claude');
+        try {
+            await fs.access(claudeDir);
+            res.json({ installed: true, claudeDir });
+        }
+        catch {
+            res.json({ installed: false, claudeDir });
+        }
+    });
+    return router;
+}

package/dist/src/server/api/export-delete.js ADDED Viewed

@@ -0,0 +1,87 @@
+import { Router as createRouter } from 'express';
+import { detectConflict } from '../../conflict-detector.js';
+import { slugify } from '../../slugify.js';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const AGENT_OWNERSHIP_REGEX = /^<!-- cwc:node:[^:\s]+:workflow:[^:\s>]+ -->$/;
+const WORKFLOW_OWNERSHIP_REGEX = /^<!-- cwc:workflow:[^:\s>]+ -->$/;
+async function safeReadFile(p) {
+    try {
+        return await fs.readFile(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export async function deleteExport(cwc, target) {
+    const workflowId = cwc.meta.id;
+    const workflowSlug = 'cwc-' + slugify(cwc.meta.name);
+    const legacyWorkflowSlug = slugify(cwc.meta.name);
+    const homeDir = os.homedir();
+    const agentsDir = target.type === 'project'
+        ? path.join(target.projectDir, '.claude', 'agents')
+        : path.join(homeDir, '.claude', 'agents');
+    const skillsDir = target.type === 'project'
+        ? path.join(target.projectDir, '.claude', 'skills')
+        : path.join(homeDir, '.claude', 'skills');
+    const deleted = [];
+    const skipped = [];
+    const notFound = [];
+    for (const node of cwc.nodes) {
+        if (node.agentRef) {
+            // Ref nodes point to pre-existing agent files — never delete them
+            continue;
+        }
+        const slug = node.exportedSlug ?? slugify(node.agent.name);
+        const agentPath = path.join(agentsDir, `${slug}.md`);
+        const content = await safeReadFile(agentPath);
+        if (content === null) {
+            notFound.push(agentPath);
+            continue;
+        }
+        const status = detectConflict(content, AGENT_OWNERSHIP_REGEX, workflowId);
+        if (status === 'owned') {
+            await fs.unlink(agentPath);
+            deleted.push(agentPath);
+        }
+        else {
+            skipped.push(agentPath);
+        }
+    }
+    for (const slug of [workflowSlug, legacyWorkflowSlug]) {
+        const skillDir = path.join(skillsDir, slug);
+        const skillFilePath = path.join(skillDir, 'SKILL.md');
+        const skillContent = await safeReadFile(skillFilePath);
+        if (skillContent !== null) {
+            const status = detectConflict(skillContent, WORKFLOW_OWNERSHIP_REGEX, workflowId);
+            if (status === 'owned') {
+                await fs.rm(skillDir, { recursive: true, force: true });
+                deleted.push(skillDir);
+            }
+            else {
+                skipped.push(skillFilePath);
+            }
+            break; // found the skill dir (new or legacy), no need to check the other
+        }
+    }
+    return { deleted, skipped, notFound };
+}
+export function exportDeleteRouter() {
+    const router = createRouter();
+    router.post('/', async (req, res) => {
+        const { cwcFile, target } = req.body;
+        if (!cwcFile || !target)
+            return void res.status(400).json({ error: 'cwcFile and target required' });
+        if (target.type === 'project' && !target.projectDir)
+            return void res.status(400).json({ error: 'projectDir required for project target' });
+        try {
+            const result = await deleteExport(cwcFile, target);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    return router;
+}

package/dist/src/server/api/export-preview.js ADDED Viewed

@@ -0,0 +1,71 @@
+import { Router as createRouter } from 'express';
+import { slugify } from '../../slugify.js';
+import { buildAgentFileContent, buildWorkflowSkillContent } from '../../file-writer.js';
+import { generateOrchestratorBody } from '../../prose-generator.js';
+import { resolveSkill } from '../../skill-resolver.js';
+import * as path from 'node:path';
+import * as os from 'node:os';
+export function exportPreviewRouter() {
+    const router = createRouter();
+    router.post('/', async (req, res) => {
+        const { cwcFile, target } = req.body;
+        if (!cwcFile || !target)
+            return void res.status(400).json({ error: 'cwcFile and target required' });
+        if (target.type === 'project' && !path.isAbsolute(target.projectDir)) {
+            return void res.status(400).json({ error: 'projectDir must be an absolute path' });
+        }
+        try {
+            const warnings = [];
+            const workflowId = cwcFile.meta.id;
+            const agentsDir = target.type === 'project'
+                ? path.join(target.projectDir, '.claude', 'agents')
+                : path.join(target.userDir ?? os.homedir(), '.claude', 'agents');
+            const workflowSlug = 'cwc-' + slugify(cwcFile.meta.name);
+            const skillsDir = target.type === 'project'
+                ? path.join(target.projectDir, '.claude', 'skills')
+                : path.join(target.userDir ?? os.homedir(), '.claude', 'skills');
+            const files = [];
+            const nodeOverrides = {};
+            for (const node of cwcFile.nodes) {
+                if (node.agentRef) {
+                    // Ref node — don't generate an agent file; collect overrides for orchestrator
+                    for (const skillSlug of node.agent.skills ?? []) {
+                        const r = await resolveSkill(skillSlug);
+                        if (!r.found)
+                            warnings.push(`Skill not found: ${skillSlug} — install it on the target machine`);
+                    }
+                    const hasOverrides = (node.agent.skills ?? []).length > 0
+                        || (node.agent.tools ?? []).length > 0
+                        || (node.agent.systemPrompt ?? '').trim().length > 0
+                        || (node.agent.completionCriteria ?? '').trim().length > 0;
+                    if (hasOverrides) {
+                        nodeOverrides[node.id] = {
+                            skills: node.agent.skills,
+                            tools: node.agent.tools,
+                            systemPrompt: node.agent.systemPrompt,
+                            completionCriteria: node.agent.completionCriteria,
+                        };
+                    }
+                    continue;
+                }
+                const slug = slugify(node.agent.name);
+                const resolvedSkills = await Promise.all((node.agent.skills ?? []).map(async (s) => {
+                    const r = await resolveSkill(s);
+                    if (!r.found)
+                        warnings.push(`Skill not found: ${s} — install it on the target machine`);
+                    return r;
+                }));
+                const content = buildAgentFileContent(node, resolvedSkills, workflowId);
+                files.push({ path: path.join(agentsDir, `${slug}.md`), content });
+            }
+            const orchestratorBody = generateOrchestratorBody(cwcFile.nodes, cwcFile.edges, cwcFile.meta.name, nodeOverrides);
+            const skillContent = buildWorkflowSkillContent(cwcFile.meta.name, cwcFile.meta.description, orchestratorBody, workflowId);
+            files.push({ path: path.join(skillsDir, workflowSlug, 'SKILL.md'), content: skillContent });
+            res.json({ files, warnings });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    return router;
+}

package/dist/src/server/api/export.js ADDED Viewed

@@ -0,0 +1,23 @@
+import { Router as createRouter } from 'express';
+import { exportWorkflow } from '../../exporter.js';
+import * as os from 'node:os';
+import * as path from 'node:path';
+export function exportRouter() {
+    const router = createRouter();
+    router.post('/', async (req, res) => {
+        const { cwcFile, target, skillsDir } = req.body;
+        if (!cwcFile || !target)
+            return void res.status(400).json({ error: 'cwcFile and target required' });
+        const opts = {
+            skillsDir: skillsDir ?? path.join(os.homedir(), '.claude', 'skills'),
+        };
+        try {
+            const result = await exportWorkflow(cwcFile, target, opts);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    return router;
+}