@microck/canonfig 2.0.0 → 2.1.0

package/dist/harness-configuration/adapters/qwen.js

@@ -0,0 +1,164 @@
+import { markdownWithFrontmatter } from "../core/frontmatter.js";
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, commandDocuments, enabledHooks, enabledMcpServerEntries, hookCommand, secretValue, skillArtifacts, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+const QWEN_EVENT_MAP = {
+    session_start: "SessionStart",
+    session_end: "SessionEnd",
+    prompt_submit: "UserPromptSubmit",
+    before_tool: "PreToolUse",
+    after_tool: "PostToolUse",
+    before_compact: "PreCompact",
+    stop: "Stop",
+    subagent_start: "SubagentStart",
+    subagent_stop: "SubagentStop",
+};
+const QWEN_MATCHER_EVENTS = new Set([
+    "SessionStart",
+    "SessionEnd",
+    "PreToolUse",
+    "PostToolUse",
+    "PreCompact",
+    "SubagentStart",
+    "SubagentStop",
+]);
+function qwenHooks(context) {
+    const hooks = {};
+    const diagnostics = [];
+    for (const hook of enabledHooks(context)) {
+        const event = QWEN_EVENT_MAP[hook.event];
+        if (!event) {
+            diagnostics.push({
+                level: "warning",
+                code: "HOOK_EVENT_UNSUPPORTED",
+                target: "qwen",
+                message: `Qwen Code cannot directly map hook event ${hook.event}; it was skipped.`,
+            });
+            continue;
+        }
+        const entry = {
+            ...(QWEN_MATCHER_EVENTS.has(event) ? { matcher: "*" } : {}),
+            hooks: [{
+                    type: "command",
+                    command: hookCommand("qwen", hook),
+                    timeout: hook.timeoutMs,
+                }],
+        };
+        (hooks[event] ??= []).push(entry);
+    }
+    return { hooks, diagnostics };
+}
+function qwenMcpServer(server) {
+    const common = {
+        ...(server.timeoutMs === undefined ? {} : { timeout: server.timeoutMs }),
+        ...(server.enabledTools?.length ? { includeTools: server.enabledTools } : {}),
+        ...(server.disabledTools?.length ? { excludeTools: server.disabledTools } : {}),
+    };
+    if (server.transport === "stdio") {
+        return {
+            command: server.command,
+            ...(server.args.length ? { args: server.args } : {}),
+            ...(server.cwd ? { cwd: server.cwd } : {}),
+            ...(Object.keys(server.env).length
+                ? {
+                    env: Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, secretValue(value)])),
+                }
+                : {}),
+            ...common,
+        };
+    }
+    return {
+        ...(server.transport === "sse" ? { url: server.url } : { httpUrl: server.url }),
+        ...(Object.keys(server.headers).length
+            ? {
+                headers: Object.fromEntries(Object.entries(server.headers).map(([key, value]) => [key, secretValue(value)])),
+            }
+            : {}),
+        ...common,
+    };
+}
+function qwenMcpMap(context) {
+    return Object.fromEntries(enabledMcpServerEntries(context).map(([name, server]) => [
+        name,
+        qwenMcpServer(server),
+    ]));
+}
+export const qwenAdapter = {
+    descriptor: descriptor("qwen", "Qwen Code", ["qwen"], [
+        "https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/skills.md",
+        "https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/mcp.md",
+        "https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/hooks.md",
+        "https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/sub-agents.md",
+        "https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/commands.md",
+    ], {
+        instructions: "portable",
+        rules: "portable",
+        skills: "native",
+        mcp: "native",
+        hooks: "native",
+        agents: "native",
+        commands: "native",
+    }, [
+        "Qwen Code stores project MCP servers and hooks together in .qwen/settings.json; Canonfig owns only the projected keys.",
+        "Canonical streamable HTTP servers map to Qwen's httpUrl field, while legacy SSE servers retain url.",
+    ], "2026-08-26"),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        artifacts.push(...await skillArtifacts(context, ".qwen/skills", "qwen"));
+        if (enabledMcpServerEntries(context).length > 0) {
+            artifacts.push({
+                kind: "json",
+                path: ".qwen/settings.json",
+                owner: "qwen",
+                operations: [{
+                        kind: "managed-map",
+                        path: ["mcpServers"],
+                        entries: qwenMcpMap(context),
+                        collision: "error",
+                    }],
+            });
+        }
+        const compiledHooks = qwenHooks(context);
+        diagnostics.push(...compiledHooks.diagnostics);
+        if (Object.keys(compiledHooks.hooks).length > 0) {
+            artifacts.push({
+                kind: "json",
+                path: ".qwen/settings.json",
+                owner: "qwen",
+                operations: [{
+                        kind: "managed-hooks",
+                        path: ["hooks"],
+                        hooks: compiledHooks.hooks,
+                        marker: ".canonfig/.runtime/hook-runner.mjs",
+                    }],
+            });
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            const tools = nativeTools("qwen", agent);
+            artifacts.push({
+                kind: "replace",
+                path: `.qwen/agents/${agent.id}.md`,
+                owner: "qwen",
+                content: markdownWithFrontmatter({
+                    name: agent.id,
+                    description: agent.description,
+                    ...(agent.model === "inherit" ? {} : { model: agent.model }),
+                    tools,
+                    ...(!agent.writable
+                        ? { disallowedTools: ["edit", "write_file"] }
+                        : {}),
+                }, content),
+            });
+        }
+        for (const { command, content } of await commandDocuments(context)) {
+            artifacts.push({
+                kind: "replace",
+                path: `.qwen/commands/${command.id}.md`,
+                owner: "qwen",
+                content: markdownWithFrontmatter({ description: command.description }, content),
+            });
+        }
+        return { artifacts, diagnostics };
+    },
+};

package/dist/harness-configuration/adapters/shared-common.js

@@ -0,0 +1,66 @@
+import { hookRegistryJson, hookRunnerSource } from "../templates/runtime.js";
+import { readCanonfigText, skillArtifacts } from "./shared-documents.js";
+import { enabledHooks } from "./shared-hooks.js";
+import { hasEnabledMcpServers, standardMcpMap } from "./shared-mcp.js";
+export async function commonArtifacts(context) {
+    const rootInstructions = await readCanonfigText(context, context.config.instructions.root);
+    const scoped = context.config.instructions.rules.length === 0 ? "" : [
+        "",
+        "## Scoped instruction sources",
+        "",
+        ...context.config.instructions.rules.map((rule) => {
+            const scope = rule.paths.length ? rule.paths.map((item) => `\`${item}\``).join(", ") : "all files";
+            return `- Read \`.canonfig/${rule.file}\` when working on ${scope}.`;
+        }),
+    ].join("\n");
+    const artifacts = [
+        {
+            kind: "managed-text",
+            path: "AGENTS.md",
+            owner: "common",
+            marker: "instructions",
+            comments: "html",
+            placement: "end",
+            content: `${rootInstructions.trim()}${scoped}`,
+        },
+        {
+            kind: "managed-text",
+            path: ".gitignore",
+            owner: "common",
+            marker: "state-ignore",
+            comments: "hash",
+            placement: "end",
+            content: ".canonfig/.harness-state.json",
+        },
+    ];
+    artifacts.push(...await skillArtifacts(context, ".agents/skills", "common"));
+    if (hasEnabledMcpServers(context)) {
+        artifacts.push({
+            kind: "json",
+            path: ".mcp.json",
+            owner: "common",
+            operations: [{
+                    kind: "managed-map",
+                    path: ["mcpServers"],
+                    entries: standardMcpMap(context),
+                    collision: "error",
+                }],
+        });
+    }
+    const hooks = enabledHooks(context);
+    if (hooks.length > 0) {
+        artifacts.push({
+            kind: "replace",
+            path: ".canonfig/.runtime/hook-runner.mjs",
+            owner: "common",
+            content: hookRunnerSource(),
+            mode: 0o755,
+        }, {
+            kind: "replace",
+            path: ".canonfig/.runtime/hooks.json",
+            owner: "common",
+            content: hookRegistryJson(hooks),
+        });
+    }
+    return artifacts;
+}

package/dist/harness-configuration/adapters/shared-documents.js

@@ -0,0 +1,117 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { assertRealPathInside, assertSafeRelativePath, resolveInside, toPosix } from "../core/path.js";
+import { markdownWithFrontmatter } from "../core/frontmatter.js";
+import { walkFiles } from "../core/filesystem.js";
+export const RUNTIME_MARKER = ".canonfig/.runtime/hook-runner.mjs";
+export async function readCanonfigText(context, relativePath) {
+    const safe = assertSafeRelativePath(relativePath);
+    const absolute = resolveInside(context.canonfigDir, safe);
+    await assertRealPathInside(context.canonfigDir, absolute);
+    return fs.readFile(absolute, "utf8");
+}
+export async function copyDirectoryArtifacts(context, sourceRelative, destination, owner) {
+    const source = resolveInside(context.canonfigDir, assertSafeRelativePath(sourceRelative));
+    try {
+        await assertRealPathInside(context.canonfigDir, source);
+        await fs.access(source);
+    }
+    catch {
+        return [];
+    }
+    const files = await walkFiles(source);
+    const artifacts = [];
+    for (const file of files.sort()) {
+        const absolute = path.join(source, file);
+        const [content, stat] = await Promise.all([fs.readFile(absolute), fs.stat(absolute)]);
+        const executable = (stat.mode & 0o111) !== 0;
+        artifacts.push({
+            kind: "replace",
+            path: toPosix(path.posix.join(destination, toPosix(file))),
+            owner,
+            content,
+            ...(executable ? { mode: 0o755 } : {}),
+        });
+    }
+    return artifacts;
+}
+export async function skillArtifacts(context, destination, owner) {
+    const artifacts = [];
+    for (const root of context.config.skills.roots) {
+        artifacts.push(...await copyDirectoryArtifacts(context, root, destination, owner));
+    }
+    return artifacts;
+}
+export async function ruleDocuments(context) {
+    return Promise.all(context.config.instructions.rules.map(async (rule) => ({
+        rule,
+        content: await readCanonfigText(context, rule.file),
+    })));
+}
+export async function agentDocuments(context) {
+    return Promise.all(context.config.agents.map(async (agent) => ({
+        agent,
+        content: await readCanonfigText(context, agent.file),
+    })));
+}
+export async function commandDocuments(context) {
+    return Promise.all(context.config.commands.map(async (command) => ({
+        command,
+        content: await readCanonfigText(context, command.file),
+    })));
+}
+export function agentMarkdown(agent, content, tools) {
+    return markdownWithFrontmatter({
+        name: agent.id,
+        description: agent.description,
+        ...(agent.model === "inherit" ? {} : { model: agent.model }),
+        tools,
+    }, content);
+}
+export function commandMarkdown(command, content) {
+    return markdownWithFrontmatter({
+        description: command.description,
+        ...(command.argumentHint ? { "argument-hint": command.argumentHint } : {}),
+    }, content);
+}
+export function ruleMarkdown(rule, content, extra = {}) {
+    return markdownWithFrontmatter({
+        description: rule.description ?? `Canonfig rule: ${rule.id}`,
+        ...(rule.paths.length ? { globs: rule.paths } : {}),
+        ...extra,
+    }, content);
+}
+export function skillMarkdown(name, description, content, metadata = {}) {
+    return markdownWithFrontmatter({ name, description, ...metadata }, content);
+}
+function translatedSkillName(owner, kind, id) {
+    return `canonfig-${owner}-${kind}-${id}`;
+}
+export async function commandSkillArtifacts(context, destination, owner) {
+    const documents = await commandDocuments(context);
+    return documents.map(({ command, content }) => {
+        const name = translatedSkillName(owner, "command", command.id);
+        return {
+            kind: "replace",
+            path: `${destination}/${name}/SKILL.md`,
+            owner,
+            content: skillMarkdown(name, command.description, content, {
+                metadata: { canonfig: { kind: "command", sourceId: command.id, argumentHint: command.argumentHint ?? null } },
+            }),
+        };
+    });
+}
+export async function agentSkillArtifacts(context, destination, owner) {
+    const documents = await agentDocuments(context);
+    return documents.map(({ agent, content }) => {
+        const name = translatedSkillName(owner, "agent", agent.id);
+        return {
+            kind: "replace",
+            path: `${destination}/${name}/SKILL.md`,
+            owner,
+            content: skillMarkdown(name, agent.description, content, {
+                metadata: { canonfig: { kind: "agent", sourceId: agent.id, model: agent.model, tools: agent.tools } },
+            }),
+        };
+    });
+}

package/dist/harness-configuration/adapters/shared-hooks.js

@@ -0,0 +1,186 @@
+export function hookCommand(target, hook) {
+    return `node \".canonfig/.runtime/hook-runner.mjs\" --hook ${hook.id} --target ${target} --event ${hook.event}`;
+}
+export function enabledHooks(context) {
+    return context.config.hooks.filter((hook) => hook.enabled);
+}
+function timeoutSeconds(timeoutMs) {
+    return Math.max(1, Math.ceil(timeoutMs / 1000));
+}
+export const CLAUDE_EVENT_MAP = {
+    session_start: "SessionStart",
+    session_end: "SessionEnd",
+    prompt_submit: "UserPromptSubmit",
+    before_agent: "PreInvocation",
+    after_agent: "PostInvocation",
+    before_tool: "PreToolUse",
+    after_tool: "PostToolUse",
+    before_compact: "PreCompact",
+    after_compact: "PostCompact",
+    stop: "Stop",
+    subagent_start: "SubagentStart",
+    subagent_stop: "SubagentStop",
+};
+export const CODEX_EVENT_MAP = {
+    session_start: "SessionStart",
+    session_end: "SessionEnd",
+    prompt_submit: "UserPromptSubmit",
+    before_tool: "PreToolUse",
+    after_tool: "PostToolUse",
+    before_compact: "PreCompact",
+    after_compact: "PostCompact",
+    stop: "Stop",
+    subagent_start: "SubagentStart",
+    subagent_stop: "SubagentStop",
+};
+export const DEVIN_EVENT_MAP = {
+    session_start: "SessionStart",
+    session_end: "SessionEnd",
+    prompt_submit: "UserPromptSubmit",
+    before_tool: "PreToolUse",
+    after_tool: "PostToolUse",
+    after_compact: "PostCompaction",
+    stop: "Stop",
+};
+export const GROK_EVENT_MAP = {
+    session_start: "SessionStart",
+    session_end: "SessionEnd",
+    prompt_submit: "UserPromptSubmit",
+    before_tool: "PreToolUse",
+    after_tool: "PostToolUse",
+    before_compact: "PreCompact",
+    after_compact: "PostCompact",
+    stop: "Stop",
+    subagent_start: "SubagentStart",
+    subagent_stop: "SubagentStop",
+};
+export function claudeStyleHooks(context, eventMap = CLAUDE_EVENT_MAP) {
+    const hooks = {};
+    const diagnostics = [];
+    for (const hook of enabledHooks(context)) {
+        const nativeEvent = eventMap[hook.event];
+        if (!nativeEvent) {
+            diagnostics.push({
+                level: "warning",
+                code: "HOOK_EVENT_UNSUPPORTED",
+                target: context.target,
+                message: `${context.target} cannot directly map hook event ${hook.event}; it was skipped.`,
+            });
+            continue;
+        }
+        const entry = {
+            matcher: ".*",
+            hooks: [{
+                    type: "command",
+                    command: hookCommand(context.target, hook),
+                    timeout: timeoutSeconds(hook.timeoutMs),
+                }],
+        };
+        (hooks[nativeEvent] ??= []).push(entry);
+    }
+    return { hooks, diagnostics };
+}
+export function cursorHooks(context) {
+    const eventMap = {
+        session_start: "sessionStart",
+        session_end: "sessionEnd",
+        prompt_submit: "beforeSubmitPrompt",
+        before_tool: "preToolUse",
+        after_tool: "postToolUse",
+        before_compact: "preCompact",
+        stop: "stop",
+        subagent_start: "subagentStart",
+        subagent_stop: "subagentStop",
+    };
+    const hooks = {};
+    const diagnostics = [];
+    for (const hook of enabledHooks(context)) {
+        const event = eventMap[hook.event];
+        if (!event) {
+            diagnostics.push({
+                level: "warning",
+                code: "HOOK_EVENT_UNSUPPORTED",
+                target: "cursor",
+                message: `Cursor cannot directly map hook event ${hook.event}; it was skipped.`,
+            });
+            continue;
+        }
+        (hooks[event] ??= []).push({
+            command: hookCommand("cursor", hook),
+            ...(event === "preToolUse" || event === "postToolUse" ? { matcher: ".*" } : {}),
+        });
+    }
+    return { hooks, diagnostics };
+}
+export function copilotHooks(context) {
+    const eventMap = {
+        session_start: "sessionStart",
+        session_end: "sessionEnd",
+        prompt_submit: "userPromptSubmitted",
+        before_tool: "preToolUse",
+        after_tool: "postToolUse",
+        stop: "agentStop",
+        subagent_start: "subagentStart",
+        subagent_stop: "subagentStop",
+        before_compact: "preCompact",
+    };
+    const hooks = {};
+    const diagnostics = [];
+    for (const hook of enabledHooks(context)) {
+        const event = eventMap[hook.event];
+        if (!event) {
+            diagnostics.push({
+                level: "warning",
+                code: "HOOK_EVENT_UNSUPPORTED",
+                target: "copilot-cli",
+                message: `Copilot CLI cannot directly map hook event ${hook.event}; it was skipped.`,
+            });
+            continue;
+        }
+        const command = hookCommand("copilot-cli", hook);
+        (hooks[event] ??= []).push({
+            type: "command",
+            bash: command,
+            powershell: command,
+            cwd: ".",
+            timeoutSec: timeoutSeconds(hook.timeoutMs),
+            ...(event === "preToolUse" || event === "postToolUse" ? { matcher: ".*" } : {}),
+        });
+    }
+    return { hooks, diagnostics };
+}
+export function antigravityHooks(context) {
+    const eventMap = {
+        before_tool: "PreToolUse",
+        after_tool: "PostToolUse",
+        before_agent: "PreInvocation",
+        after_agent: "PostInvocation",
+        stop: "Stop",
+    };
+    const entries = {};
+    const diagnostics = [];
+    for (const hook of enabledHooks(context)) {
+        const event = eventMap[hook.event];
+        if (!event) {
+            diagnostics.push({
+                level: "warning",
+                code: "HOOK_EVENT_UNSUPPORTED",
+                target: "antigravity",
+                message: `Antigravity cannot map hook event ${hook.event}; it was skipped.`,
+            });
+            continue;
+        }
+        const handler = {
+            type: "command",
+            command: hookCommand("antigravity", hook),
+            timeout: timeoutSeconds(hook.timeoutMs),
+        };
+        entries[`canonfig-${hook.id}`] = {
+            enabled: true,
+            [event]: event === "PreToolUse" || event === "PostToolUse"
+                ? [{ matcher: ".*", hooks: [handler] }]
+                : [handler],
+        };
+    }
+    return { entries, diagnostics };
+}