mova-claude-import 0.1.1 → 0.1.3

package/dist/control_check_v0.js

@@ -3,6 +3,8 @@ import path from "node:path";
 import { stableStringify } from "./stable_json.js";
 import { stableSha256 } from "./redaction.js";
 import { buildMovaControlEntryV0, MOVA_CONTROL_ENTRY_MARKER } from "./mova_overlay_v0.js";
+import { controlToMcpJson, controlToSettingsV0, normalizeControlV0 } from "./control_v0.js";
+import { validateControlV0Schema } from "./control_v0_schema.js";
 async function exists(p) {
     try {
         await fs.stat(p);
@@ -23,13 +25,49 @@ async function writeJson(p, obj) {
 function computeRunId(parts) {
     return stableSha256(parts.join("|")).slice(0, 16);
 }
+function normalizeJson(obj) {
+    return stableStringify(obj);
+}
+function isPlaceholder(value) {
+    return /^\$\{[A-Z0-9_]+(?::-?[^}]+)?\}$/.test(value.trim());
+}
+function validateMcpEnvValues(servers) {
+    if (!servers || typeof servers !== "object")
+        return [];
+    const issues = [];
+    const entries = Array.isArray(servers)
+        ? servers.map((server, idx) => [server?.name ?? `index_${idx}`, server])
+        : Object.entries(servers);
+    for (const [name, server] of entries) {
+        if (!server || typeof server !== "object")
+            continue;
+        const env = server.env;
+        if (!env || typeof env !== "object")
+            continue;
+        for (const [key, value] of Object.entries(env)) {
+            if (typeof value !== "string")
+                continue;
+            if (!value.includes("${"))
+                continue;
+            if (!isPlaceholder(value)) {
+                issues.push({ server: String(name), key, value });
+            }
+        }
+    }
+    return issues;
+}
 export async function controlCheckV0(projectDir, profilePath, outDir) {
     const profile = await readJson(profilePath);
     const claudePath = path.join(projectDir, "CLAUDE.md");
     const mcpPath = path.join(projectDir, ".mcp.json");
+    const settingsPath = path.join(projectDir, ".claude", "settings.json");
     const claudeExists = await exists(claudePath);
     const mcpExists = await exists(mcpPath);
-    const marker = profile?.anthropic?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER;
+    const settingsExists = await exists(settingsPath);
+    const isControlV0 = profile?.version === "control_v0";
+    const marker = isControlV0
+        ? profile?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER
+        : profile?.anthropic?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER;
     const runId = computeRunId([profilePath, claudeExists ? "claude" : "", mcpExists ? "mcp" : "", marker]);
     const runBase = path.join(outDir, "mova", "claude_control", "v0", "runs", runId);
     const overlayParams = {
@@ -42,39 +80,172 @@ export async function controlCheckV0(projectDir, profilePath, outDir) {
         qualityReportFile: "quality_report_v0.json",
         exportManifestFile: "export_manifest_v0.json",
     };
-    const actions = [];
-    if (profile?.anthropic?.claude_md?.inject_control_entry) {
-        actions.push({
-            target: "CLAUDE.md",
-            action: "insert_or_update_control_entry",
-            marker,
-        });
+    if (!isControlV0) {
+        const actions = [];
+        if (profile?.anthropic?.claude_md?.inject_control_entry) {
+            actions.push({
+                target: "CLAUDE.md",
+                action: "insert_or_update_control_entry",
+                marker,
+            });
+        }
+        if (profile?.anthropic?.mcp?.servers && mcpExists) {
+            actions.push({
+                target: ".mcp.json",
+                action: "merge_servers",
+                summary: "merge profile servers with project mcp.json",
+            });
+        }
+        const plan = {
+            profile_version: "v0",
+            run_id: runId,
+            project_dir: projectDir,
+            profile_path: profilePath,
+            actions,
+        };
+        const summary = {
+            run_id: runId,
+            outcome_code: "PREVIEW",
+            actions_count: actions.length,
+            control_entry_preview: profile?.anthropic?.claude_md?.inject_control_entry
+                ? buildMovaControlEntryV0(overlayParams)
+                : null,
+        };
+        const planPath = path.join(runBase, "control_plan_v0.json");
+        const summaryPath = path.join(runBase, "control_summary_v0.json");
+        await writeJson(planPath, plan);
+        await writeJson(summaryPath, summary);
+        return { run_id: runId, plan_path: planPath, summary_path: summaryPath };
+    }
+    const schemaValidation = await validateControlV0Schema(profile);
+    const control = normalizeControlV0(profile).control;
+    const planPath = path.join(runBase, "control_plan_v0.json");
+    const summaryPath = path.join(runBase, "control_summary_v0.json");
+    if (!schemaValidation.ok) {
+        const summary = {
+            run_id: runId,
+            outcome_code: "INVALID_SCHEMA",
+            errors: schemaValidation.errors ?? [],
+        };
+        await writeJson(planPath, { profile_version: "v0", run_id: runId, project_dir: projectDir, profile_path: profilePath, actions: [] });
+        await writeJson(summaryPath, summary);
+        return { run_id: runId, plan_path: planPath, summary_path: summaryPath, exit_code: 2 };
+    }
+    const mcpJsonExpected = controlToMcpJson(control);
+    const settingsExpected = controlToSettingsV0(control);
+    const missing = [];
+    const drift = [];
+    if (!claudeExists)
+        missing.push("CLAUDE.md");
+    if (!settingsExists)
+        missing.push(".claude/settings.json");
+    if (!mcpExists)
+        missing.push(".mcp.json");
+    if (claudeExists && control.claude_md.inject_control_entry) {
+        const claude = await fs.readFile(claudePath, "utf8");
+        if (!claude.includes(control.claude_md.marker)) {
+            drift.push({ path: "CLAUDE.md", expected: `marker:${control.claude_md.marker}`, actual: "missing_marker" });
+        }
+    }
+    if (settingsExists) {
+        const actual = normalizeJson(await readJson(settingsPath));
+        const expected = normalizeJson(settingsExpected);
+        if (actual !== expected) {
+            drift.push({ path: ".claude/settings.json", expected, actual });
+        }
     }
-    if (profile?.anthropic?.mcp?.servers && mcpExists) {
-        actions.push({
-            target: ".mcp.json",
-            action: "merge_servers",
-            summary: "merge profile servers with project mcp.json",
-        });
+    if (mcpExists) {
+        const actual = normalizeJson(await readJson(mcpPath));
+        const expected = normalizeJson(mcpJsonExpected);
+        if (actual !== expected) {
+            drift.push({ path: ".mcp.json", expected, actual });
+        }
+    }
+    if (control.lsp.managed) {
+        const lspPath = control.lsp.config_path;
+        const abs = path.join(projectDir, lspPath);
+        if (!(await exists(abs))) {
+            missing.push(lspPath);
+        }
+        else {
+            const actual = normalizeJson(await readJson(abs));
+            const expected = normalizeJson({ enabled_plugins: control.lsp.enabled_plugins });
+            if (actual !== expected) {
+                drift.push({ path: lspPath, expected, actual });
+            }
+        }
+    }
+    if (control.observability.enable && control.observability.writer?.script_path) {
+        const obsPath = path.join(projectDir, control.observability.writer.script_path);
+        if (!(await exists(obsPath))) {
+            missing.push(control.observability.writer.script_path);
+        }
+    }
+    const assets = [
+        ...control.assets.skills,
+        ...control.assets.agents,
+        ...control.assets.commands,
+        ...control.assets.rules,
+        ...control.assets.hooks,
+        ...control.assets.workflows,
+        ...control.assets.docs,
+        ...control.assets.dotfiles,
+        ...control.assets.schemas,
+    ];
+    for (const asset of assets) {
+        const abs = path.join(projectDir, asset.path);
+        if (!(await exists(abs))) {
+            missing.push(asset.path);
+        }
+    }
+    const envIssues = validateMcpEnvValues(control.mcp.servers);
+    let outcome = "OK";
+    let exitCode = 0;
+    if (envIssues.length > 0) {
+        outcome = "INVALID_CONTROL";
+        exitCode = 2;
+    }
+    else if (missing.length > 0) {
+        outcome = "MISSING_REQUIRED_FILES";
+        exitCode = 4;
+    }
+    else if (drift.length > 0) {
+        outcome = "DRIFT";
+        exitCode = 3;
     }
     const plan = {
         profile_version: "v0",
         run_id: runId,
         project_dir: projectDir,
         profile_path: profilePath,
-        actions,
+        actions: [
+            {
+                target: "CLAUDE.md",
+                action: "ensure_control_entry",
+                marker: control.claude_md.marker,
+            },
+            {
+                target: ".claude/settings.json",
+                action: "overwrite",
+            },
+            {
+                target: ".mcp.json",
+                action: "overwrite",
+            },
+        ],
     };
     const summary = {
         run_id: runId,
-        outcome_code: "PREVIEW",
-        actions_count: actions.length,
-        control_entry_preview: profile?.anthropic?.claude_md?.inject_control_entry
-            ? buildMovaControlEntryV0(overlayParams)
-            : null,
+        outcome_code: outcome,
+        exit_code: exitCode,
+        missing,
+        drift_count: drift.length,
+        invalid_mcp_env: envIssues,
+        control_entry_preview: control.claude_md.inject_control_entry ? buildMovaControlEntryV0(overlayParams) : null,
     };
-    const planPath = path.join(runBase, "control_plan_v0.json");
-    const summaryPath = path.join(runBase, "control_summary_v0.json");
+    const reportPath = path.join(runBase, "control_check_report_v0.json");
     await writeJson(planPath, plan);
     await writeJson(summaryPath, summary);
-    return { run_id: runId, plan_path: planPath, summary_path: summaryPath };
+    await writeJson(reportPath, { summary, drift, missing, invalid_mcp_env: envIssues });
+    return { run_id: runId, plan_path: planPath, summary_path: summaryPath, exit_code: exitCode };
 }

package/dist/control_prefill_v0.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { stableStringify } from "./stable_json.js";
 import { loadControlContractsV0 } from "./control_contracts_v0.js";
+import { controlFromSettingsV0, normalizeControlV0 } from "./control_v0.js";
 async function exists(p) {
     try {
         await fs.stat(p);
@@ -11,6 +12,22 @@ async function exists(p) {
         return false;
     }
 }
+async function listFilesRec(dir) {
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const e of entries) {
+            const abs = path.join(current, e.name);
+            if (e.isDirectory())
+                stack.push(abs);
+            else if (e.isFile())
+                out.push(abs);
+        }
+    }
+    return out;
+}
 async function readJson(p) {
     const raw = await fs.readFile(p, "utf8");
     return JSON.parse(raw);
@@ -25,27 +42,117 @@ export async function controlPrefillV0(projectDir, outDir) {
     const mcpPath = path.join(projectDir, ".mcp.json");
     const settingsPath = path.join(projectDir, ".claude", "settings.json");
     const settingsLocalPath = path.join(projectDir, ".claude", "settings.local.json");
-    let mcpServers = {};
+    let mcpParsed;
     let mcpFound = false;
     if (await exists(mcpPath)) {
-        const parsed = await readJson(mcpPath);
-        if (Array.isArray(parsed?.servers)) {
-            mcpServers = { servers: parsed.servers };
-        }
-        else if (parsed?.servers && typeof parsed.servers === "object") {
-            mcpServers = { servers: parsed.servers };
-        }
+        mcpParsed = await readJson(mcpPath);
         mcpFound = true;
     }
     if (template?.anthropic?.mcp) {
-        template.anthropic.mcp.servers = mcpServers.servers ?? {};
+        const servers = mcpParsed?.mcpServers ?? mcpParsed?.servers ?? {};
+        template.anthropic.mcp.servers = servers;
+    }
+    let settingsParsed;
+    if (await exists(settingsPath)) {
+        settingsParsed = await readJson(settingsPath);
+    }
+    const controlDerived = controlFromSettingsV0(settingsParsed, mcpParsed);
+    const control = normalizeControlV0(controlDerived.control).control;
+    const skills = [];
+    const skillsRoot = path.join(projectDir, ".claude", "skills");
+    if (await exists(skillsRoot)) {
+        const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const rel = `.claude/skills/${entry.name}/SKILL.md`;
+            const abs = path.join(skillsRoot, entry.name, "SKILL.md");
+            if (await exists(abs)) {
+                skills.push({ path: rel, mode: "copy_through", source_path: rel });
+            }
+        }
+    }
+    const assetDirs = [
+        { key: "agents", root: path.join(projectDir, ".claude", "agents"), prefix: ".claude/agents" },
+        { key: "commands", root: path.join(projectDir, ".claude", "commands"), prefix: ".claude/commands" },
+        { key: "rules", root: path.join(projectDir, ".claude", "rules"), prefix: ".claude/rules" },
+        { key: "hooks", root: path.join(projectDir, ".claude", "hooks"), prefix: ".claude/hooks" },
+    ];
+    const assetMap = {
+        agents: [],
+        commands: [],
+        rules: [],
+        hooks: [],
+        workflows: [],
+        docs: [],
+        dotfiles: [],
+        schemas: [],
+    };
+    for (const dir of assetDirs) {
+        if (!(await exists(dir.root)))
+            continue;
+        const files = await listFilesRec(dir.root);
+        for (const abs of files) {
+            const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+            assetMap[dir.key].push({ path: rel, mode: "copy_through", source_path: rel });
+        }
+    }
+    const docsCandidates = [
+        path.join(projectDir, ".claude", "settings.md"),
+        path.join(projectDir, ".claude", "skills", "README.md"),
+    ];
+    for (const abs of docsCandidates) {
+        if (await exists(abs)) {
+            const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+            assetMap.docs.push({ path: rel, mode: "copy_through", source_path: rel });
+        }
+    }
+    const dotfileCandidates = [path.join(projectDir, ".claude", ".gitignore")];
+    for (const abs of dotfileCandidates) {
+        if (await exists(abs)) {
+            const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+            assetMap.dotfiles.push({ path: rel, mode: "copy_through", source_path: rel });
+        }
+    }
+    const schemasRoot = path.join(projectDir, ".claude");
+    if (await exists(schemasRoot)) {
+        const files = await listFilesRec(schemasRoot);
+        for (const abs of files) {
+            if (!abs.endsWith(".schema.json"))
+                continue;
+            const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+            assetMap.schemas.push({ path: rel, mode: "copy_through", source_path: rel });
+        }
+    }
+    const workflowsRoot = path.join(projectDir, ".github", "workflows");
+    if (await exists(workflowsRoot)) {
+        const files = await listFilesRec(workflowsRoot);
+        for (const abs of files) {
+            const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+            assetMap.workflows.push({ path: rel, mode: "copy_through", source_path: rel });
+        }
+    }
+    control.assets.skills = skills.sort((a, b) => a.path.localeCompare(b.path));
+    control.assets.agents = assetMap.agents.sort((a, b) => a.path.localeCompare(b.path));
+    control.assets.commands = assetMap.commands.sort((a, b) => a.path.localeCompare(b.path));
+    control.assets.rules = assetMap.rules.sort((a, b) => a.path.localeCompare(b.path));
+    control.assets.hooks = assetMap.hooks.sort((a, b) => a.path.localeCompare(b.path));
+    control.assets.workflows = assetMap.workflows.sort((a, b) => a.path.localeCompare(b.path));
+    control.assets.docs = assetMap.docs.sort((a, b) => a.path.localeCompare(b.path));
+    control.assets.dotfiles = assetMap.dotfiles.sort((a, b) => a.path.localeCompare(b.path));
+    control.assets.schemas = assetMap.schemas.sort((a, b) => a.path.localeCompare(b.path));
+    const hasSkillEval = control.assets.hooks.some((h) => h.path.endsWith("skill-eval.sh") || h.path.endsWith("skill-eval.js"));
+    if (hasSkillEval) {
+        control.skill_eval.enable = true;
     }
     const profilePath = path.join(outDir, "claude_control_profile_v0.json");
     const reportPath = path.join(outDir, "prefill_report_v0.json");
+    const controlPath = path.join(outDir, "mova", "control_v0.json");
     const report = {
         profile_version: "v0",
         project_dir: projectDir,
         profile_path: profilePath,
+        control_path: controlPath,
         found: {
             mcp_json: mcpFound,
             settings_json: await exists(settingsPath),
@@ -53,9 +160,21 @@ export async function controlPrefillV0(projectDir, outDir) {
         },
         applied: {
             mcp_servers: mcpFound,
+            assets: {
+                skills: control.assets.skills.length,
+                agents: control.assets.agents.length,
+                commands: control.assets.commands.length,
+                rules: control.assets.rules.length,
+                hooks: control.assets.hooks.length,
+                workflows: control.assets.workflows.length,
+                docs: control.assets.docs.length,
+                dotfiles: control.assets.dotfiles.length,
+                schemas: control.assets.schemas.length,
+            },
         },
     };
     await writeJson(profilePath, template);
+    await writeJson(controlPath, control);
     await writeJson(reportPath, report);
     return { profile_path: profilePath, report_path: reportPath };
 }

package/dist/control_surface_coverage_v0.d.ts

@@ -0,0 +1,22 @@
+type CoverageReport = {
+    profile_version: "v0";
+    showcase_root: string;
+    control_path: string;
+    total_surface_files: number;
+    excluded: Array<{
+        pattern: string;
+        reason: string;
+        matches: number;
+    }>;
+    covered_count: number;
+    coverage_percent: number;
+    missing: string[];
+    covered: string[];
+};
+export declare function runControlSurfaceCoverageV0(params: {
+    showcaseRoot: string;
+    controlPath: string;
+    exclusionsPath: string;
+    reportPath: string;
+}): Promise<CoverageReport>;
+export {};

package/dist/control_surface_coverage_v0.js

@@ -0,0 +1,128 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { stableStringify } from "./stable_json.js";
+import { normalizeControlV0 } from "./control_v0.js";
+function toPosix(p) {
+    return p.replace(/\\/g, "/");
+}
+async function exists(p) {
+    try {
+        await fs.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listFilesRec(dir) {
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const abs = path.join(current, entry.name);
+            if (entry.isDirectory())
+                stack.push(abs);
+            else if (entry.isFile())
+                out.push(abs);
+        }
+    }
+    return out;
+}
+function globToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const regex = escaped.replace(/\\\*\\\*/g, ".*").replace(/\\\*/g, "[^/]*");
+    return new RegExp(`^${regex}$`);
+}
+function applyExclusions(files, exclusions) {
+    const excludedMatches = [];
+    const keep = new Set(files);
+    for (const ex of exclusions) {
+        const regex = globToRegex(ex.pattern);
+        let matches = 0;
+        for (const file of files) {
+            if (regex.test(file)) {
+                if (keep.delete(file))
+                    matches++;
+            }
+        }
+        excludedMatches.push({ pattern: ex.pattern, reason: ex.reason, matches });
+    }
+    return { remaining: Array.from(keep).sort(), excludedMatches };
+}
+async function readJson(p) {
+    const raw = await fs.readFile(p, "utf8");
+    return JSON.parse(raw);
+}
+export async function runControlSurfaceCoverageV0(params) {
+    const showcaseRoot = path.resolve(params.showcaseRoot);
+    const controlPath = path.resolve(params.controlPath);
+    const exclusionsPath = path.resolve(params.exclusionsPath);
+    const reportPath = path.resolve(params.reportPath);
+    const roots = [
+        path.join(showcaseRoot, "CLAUDE.md"),
+        path.join(showcaseRoot, ".mcp.json"),
+        path.join(showcaseRoot, ".claude"),
+        path.join(showcaseRoot, ".github", "workflows"),
+    ];
+    const surfaceFiles = [];
+    for (const root of roots) {
+        if (!(await exists(root)))
+            continue;
+        const stat = await fs.stat(root);
+        if (stat.isFile()) {
+            surfaceFiles.push(root);
+        }
+        else if (stat.isDirectory()) {
+            const files = await listFilesRec(root);
+            surfaceFiles.push(...files);
+        }
+    }
+    const surfaceRel = surfaceFiles.map((p) => toPosix(path.relative(showcaseRoot, p))).sort();
+    const controlRaw = await readJson(controlPath);
+    const control = normalizeControlV0(controlRaw).control;
+    const covered = new Set([
+        "CLAUDE.md",
+        ".mcp.json",
+        ".claude/settings.json",
+    ]);
+    const assets = [
+        ...control.assets.skills,
+        ...control.assets.agents,
+        ...control.assets.commands,
+        ...control.assets.rules,
+        ...control.assets.hooks,
+        ...control.assets.workflows,
+        ...control.assets.docs,
+        ...control.assets.dotfiles,
+        ...control.assets.schemas,
+    ];
+    for (const asset of assets) {
+        covered.add(toPosix(asset.path));
+    }
+    if (control.lsp.managed) {
+        covered.add(toPosix(control.lsp.config_path));
+    }
+    const exclusions = (await readJson(exclusionsPath))?.exclusions ?? [];
+    const { remaining, excludedMatches } = applyExclusions(surfaceRel, exclusions);
+    const missing = remaining.filter((p) => !covered.has(p));
+    const coveredList = remaining.filter((p) => covered.has(p));
+    const total = remaining.length;
+    const coveredCount = coveredList.length;
+    const coveragePercent = total === 0 ? 100 : Math.round((coveredCount / total) * 100);
+    const report = {
+        profile_version: "v0",
+        showcase_root: showcaseRoot,
+        control_path: controlPath,
+        total_surface_files: total,
+        excluded: excludedMatches,
+        covered_count: coveredCount,
+        coverage_percent: coveragePercent,
+        missing,
+        covered: coveredList,
+    };
+    await fs.mkdir(path.dirname(reportPath), { recursive: true });
+    await fs.writeFile(reportPath, stableStringify(report) + "\n", "utf8");
+    return report;
+}