mova-claude-import 0.1.1

package/dist/control_apply_v0.js

@@ -0,0 +1,86 @@
+import fs from "node:fs/promises";
+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 { ensureClaudeControlSurfacesV0 } from "./claude_profile_scaffold_v0.js";
+async function exists(p) {
+    try {
+        await fs.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(p) {
+    const raw = await fs.readFile(p, "utf8");
+    return JSON.parse(raw);
+}
+async function writeJson(p, obj) {
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, stableStringify(obj) + "\n", "utf8");
+}
+function computeRunId(parts) {
+    return stableSha256(parts.join("|")).slice(0, 16);
+}
+function updateClaude(content, marker, block) {
+    if (content.includes(marker)) {
+        const idx = content.indexOf(marker);
+        const after = content.slice(idx);
+        const split = after.split("\n\n");
+        split[0] = block.trimEnd();
+        return content.slice(0, idx) + split.join("\n\n");
+    }
+    return `${block}\n${content}`;
+}
+export async function controlApplyV0(projectDir, profilePath, outDir, mode) {
+    await ensureClaudeControlSurfacesV0(projectDir);
+    const profile = await readJson(profilePath);
+    const applyMode = mode ?? profile?.apply?.default_apply_mode ?? "preview";
+    const claudePath = path.join(projectDir, "CLAUDE.md");
+    const mcpPath = path.join(projectDir, ".mcp.json");
+    const claudeExists = await exists(claudePath);
+    const mcpExists = await exists(mcpPath);
+    const marker = profile?.anthropic?.claude_md?.marker ?? MOVA_CONTROL_ENTRY_MARKER;
+    const runId = computeRunId([profilePath, claudeExists ? "claude" : "", mcpExists ? "mcp" : "", marker, applyMode]);
+    const runBase = path.join(outDir, "mova", "claude_control", "v0", "runs", runId);
+    const overlayParams = {
+        contractsDir: "mova/claude_import/v0/contracts/",
+        artifactsDir: "mova/claude_import/v0/",
+        instructionProfileFile: "instruction_profile_v0.json",
+        skillsCatalogFile: "skills_catalog_v0.json",
+        mcpServersFile: "mcp_servers_v0.json",
+        lintReportFile: "lint_report_v0.json",
+        qualityReportFile: "quality_report_v0.json",
+        exportManifestFile: "export_manifest_v0.json",
+    };
+    const controlEntry = buildMovaControlEntryV0(overlayParams);
+    const applied = { claude_md: false, mcp_json: false, settings: false };
+    if (applyMode === "apply") {
+        if (profile?.anthropic?.claude_md?.inject_control_entry && claudeExists) {
+            const raw = await fs.readFile(claudePath, "utf8");
+            const updated = updateClaude(raw, marker, controlEntry);
+            await fs.writeFile(claudePath, updated, "utf8");
+            applied.claude_md = true;
+        }
+        if (profile?.anthropic?.mcp?.servers && mcpExists) {
+            const mcp = await readJson(mcpPath);
+            const merged = { ...mcp, servers: profile.anthropic.mcp.servers };
+            await fs.writeFile(mcpPath, stableStringify(merged) + "\n", "utf8");
+            applied.mcp_json = true;
+        }
+    }
+    const report = {
+        profile_version: "v0",
+        run_id: runId,
+        project_dir: projectDir,
+        profile_path: profilePath,
+        mode: applyMode,
+        outcome_code: applyMode === "apply" ? "APPLIED" : "PREVIEW",
+        applied,
+    };
+    const reportPath = path.join(runBase, "control_apply_report_v0.json");
+    await writeJson(reportPath, report);
+    return { run_id: runId, report_path: reportPath };
+}

package/dist/control_check_v0.d.ts

@@ -0,0 +1,7 @@
+type CheckResult = {
+    run_id: string;
+    plan_path: string;
+    summary_path: string;
+};
+export declare function controlCheckV0(projectDir: string, profilePath: string, outDir: string): Promise<CheckResult>;
+export {};

package/dist/control_check_v0.js

@@ -0,0 +1,80 @@
+import fs from "node:fs/promises";
+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";
+async function exists(p) {
+    try {
+        await fs.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(p) {
+    const raw = await fs.readFile(p, "utf8");
+    return JSON.parse(raw);
+}
+async function writeJson(p, obj) {
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, stableStringify(obj) + "\n", "utf8");
+}
+function computeRunId(parts) {
+    return stableSha256(parts.join("|")).slice(0, 16);
+}
+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 claudeExists = await exists(claudePath);
+    const mcpExists = await exists(mcpPath);
+    const 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 = {
+        contractsDir: "mova/claude_import/v0/contracts/",
+        artifactsDir: "mova/claude_import/v0/",
+        instructionProfileFile: "instruction_profile_v0.json",
+        skillsCatalogFile: "skills_catalog_v0.json",
+        mcpServersFile: "mcp_servers_v0.json",
+        lintReportFile: "lint_report_v0.json",
+        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 (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 };
+}

package/dist/control_contracts_v0.d.ts

@@ -0,0 +1,8 @@
+type ControlContractsV0 = {
+    claude_control_profile: any;
+    claude_control_mapping: any;
+    claude_control_vocab: any;
+    claude_control_precedence: any;
+};
+export declare function loadControlContractsV0(): Promise<ControlContractsV0>;
+export {};

package/dist/control_contracts_v0.js

@@ -0,0 +1,17 @@
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+async function loadJson(relPath) {
+    const url = new URL(`../${relPath}`, import.meta.url);
+    const abs = fileURLToPath(url);
+    const raw = await fs.readFile(abs, "utf8");
+    return JSON.parse(raw);
+}
+export async function loadControlContractsV0() {
+    const base = "schemas/claude_control/v0";
+    return {
+        claude_control_profile: await loadJson(`${base}/ds/ds.claude_control_profile_v0.json`),
+        claude_control_mapping: await loadJson(`${base}/ds/ds.claude_control_mapping_v0.json`),
+        claude_control_vocab: await loadJson(`${base}/global/global.claude_control_vocab_v0.json`),
+        claude_control_precedence: await loadJson(`${base}/global/global.claude_control_precedence_v0.json`),
+    };
+}

package/dist/control_prefill_v0.d.ts

@@ -0,0 +1,6 @@
+type PrefillResult = {
+    profile_path: string;
+    report_path: string;
+};
+export declare function controlPrefillV0(projectDir: string, outDir: string): Promise<PrefillResult>;
+export {};

package/dist/control_prefill_v0.js

@@ -0,0 +1,61 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { stableStringify } from "./stable_json.js";
+import { loadControlContractsV0 } from "./control_contracts_v0.js";
+async function exists(p) {
+    try {
+        await fs.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(p) {
+    const raw = await fs.readFile(p, "utf8");
+    return JSON.parse(raw);
+}
+async function writeJson(p, obj) {
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, stableStringify(obj) + "\n", "utf8");
+}
+export async function controlPrefillV0(projectDir, outDir) {
+    const contracts = await loadControlContractsV0();
+    const template = JSON.parse(JSON.stringify(contracts.claude_control_profile));
+    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 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 };
+        }
+        mcpFound = true;
+    }
+    if (template?.anthropic?.mcp) {
+        template.anthropic.mcp.servers = mcpServers.servers ?? {};
+    }
+    const profilePath = path.join(outDir, "claude_control_profile_v0.json");
+    const reportPath = path.join(outDir, "prefill_report_v0.json");
+    const report = {
+        profile_version: "v0",
+        project_dir: projectDir,
+        profile_path: profilePath,
+        found: {
+            mcp_json: mcpFound,
+            settings_json: await exists(settingsPath),
+            settings_local_json: await exists(settingsLocalPath),
+        },
+        applied: {
+            mcp_servers: mcpFound,
+        },
+    };
+    await writeJson(profilePath, template);
+    await writeJson(reportPath, report);
+    return { profile_path: profilePath, report_path: reportPath };
+}

package/dist/export_zip_v0.d.ts

@@ -0,0 +1,8 @@
+type ExportZipResult = {
+    zipAbsPath: string;
+    zipRelPath: string;
+    zipSha256: string;
+    files: string[];
+};
+export declare function createExportZipV0(outRoot: string, zipName?: string): Promise<ExportZipResult>;
+export {};

package/dist/export_zip_v0.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import yazl from "yazl";
+const FIXED_MTIME = new Date(Date.UTC(2000, 0, 1, 0, 0, 0));
+function shouldExclude(rel) {
+    const parts = rel.split("/");
+    for (const part of parts) {
+        if (part === "node_modules" || part === "dist" || part === "artifacts")
+            return true;
+        if (part.startsWith(".tmp"))
+            return true;
+    }
+    return false;
+}
+async function listFilesRec(dir) {
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        const entries = await fsp.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;
+}
+function normalizeRelPath(root, abs) {
+    return path.relative(root, abs).replace(/\\/g, "/");
+}
+async function sha256File(p) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash("sha256");
+        const stream = fs.createReadStream(p);
+        stream.on("error", reject);
+        stream.on("data", (d) => hash.update(d));
+        stream.on("end", () => resolve(hash.digest("hex")));
+    });
+}
+async function writeZip(absPath, files) {
+    await fsp.mkdir(path.dirname(absPath), { recursive: true });
+    const zipfile = new yazl.ZipFile();
+    for (const f of files) {
+        zipfile.addFile(f.abs, f.rel, { mtime: FIXED_MTIME, mode: 0o100644 });
+    }
+    const outStream = fs.createWriteStream(absPath);
+    const done = new Promise((resolve, reject) => {
+        outStream.on("close", resolve);
+        outStream.on("error", reject);
+    });
+    zipfile.outputStream.pipe(outStream);
+    zipfile.end();
+    await done;
+}
+export async function createExportZipV0(outRoot, zipName) {
+    const name = zipName && zipName.trim().length ? zipName.trim() : "export.zip";
+    const zipAbsPath = path.isAbsolute(name) ? name : path.join(outRoot, name);
+    const zipRelPath = normalizeRelPath(outRoot, zipAbsPath);
+    const absFiles = await listFilesRec(outRoot);
+    const files = absFiles
+        .map((abs) => ({ abs, rel: normalizeRelPath(outRoot, abs) }))
+        .filter((f) => !shouldExclude(f.rel))
+        .filter((f) => f.rel !== zipRelPath)
+        .filter((f) => f.rel !== "mova/claude_import/v0/export_manifest_v0.json")
+        .sort((a, b) => a.rel.localeCompare(b.rel));
+    await writeZip(zipAbsPath, files);
+    const zipSha256 = await sha256File(zipAbsPath);
+    return {
+        zipAbsPath,
+        zipRelPath,
+        zipSha256,
+        files: files.map((f) => f.rel),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+export type ImportOptions = {
+    projectDir: string;
+    outDir: string;
+    includeLocal: boolean;
+    includeUserSettings: boolean;
+    dryRun: boolean;
+    strict: boolean;
+    emitProfile: boolean;
+    emitZip: boolean;
+    zipName?: string;
+    emitOverlay: boolean;
+};
+export type ImportResult = {
+    ok: boolean;
+    exit_code?: number;
+    run_id: string;
+    out_dir: string;
+    imported: {
+        claude_md: boolean;
+        mcp_json: boolean;
+        skills_count: number;
+    };
+    skipped: Array<{
+        path: string;
+        reason: string;
+    }>;
+    lint_summary: string;
+};
+export { runImport } from "./run_import.js";
+export { scanInputPolicyV0 } from "./input_policy_v0.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { runImport } from "./run_import.js";
+export { scanInputPolicyV0 } from "./input_policy_v0.js";

package/dist/init_v0.d.ts

@@ -0,0 +1,7 @@
+type InitResult = {
+    createdFiles: string[];
+    zipRelPath?: string;
+    zipSha256?: string;
+};
+export declare function initProfileV0(outRoot: string, emitZip: boolean): Promise<InitResult>;
+export {};

package/dist/init_v0.js

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getAnthropicProfileV0Files } from "./anthropic_profile_v0.js";
+import { stableStringify } from "./stable_json.js";
+import { createExportZipV0 } from "./export_zip_v0.js";
+import { writeCleanClaudeProfileScaffoldV0 } from "./claude_profile_scaffold_v0.js";
+async function writeTextFile(absPath, content) {
+    await fs.mkdir(path.dirname(absPath), { recursive: true });
+    await fs.writeFile(absPath, content, "utf8");
+}
+async function writeJsonFile(absPath, obj) {
+    await fs.mkdir(path.dirname(absPath), { recursive: true });
+    await fs.writeFile(absPath, stableStringify(obj) + "\n", "utf8");
+}
+export async function initProfileV0(outRoot, emitZip) {
+    const createdFiles = [];
+    await writeCleanClaudeProfileScaffoldV0(outRoot);
+    const profileFiles = getAnthropicProfileV0Files();
+    for (const [rel, content] of Object.entries(profileFiles)) {
+        if (rel === "CLAUDE.md" || rel === ".claude/settings.json")
+            continue;
+        await writeTextFile(path.join(outRoot, rel), content);
+        createdFiles.push(rel);
+    }
+    const movaBase = path.join(outRoot, "mova", "claude_import", "v0");
+    const initManifestRel = path.join("mova", "claude_import", "v0", "init_manifest_v0.json").replace(/\\/g, "/");
+    let zipRelPath;
+    let zipSha256;
+    if (emitZip) {
+        const exportZip = await createExportZipV0(outRoot);
+        zipRelPath = exportZip.zipRelPath;
+        zipSha256 = exportZip.zipSha256;
+    }
+    const initManifest = {
+        profile_version: "v0",
+        created_files: createdFiles.slice().sort(),
+        zip_rel_path: zipRelPath ?? null,
+        zip_sha256: zipSha256 ?? null,
+    };
+    await writeJsonFile(path.join(outRoot, initManifestRel), initManifest);
+    createdFiles.push(initManifestRel);
+    return {
+        createdFiles,
+        zipRelPath,
+        zipSha256,
+    };
+}

package/dist/input_policy_v0.d.ts

@@ -0,0 +1,26 @@
+export type InputPolicyKind = "claude_settings_local" | "local_file" | "env_file" | "private_key_like" | "other";
+export type InputPolicyEntry = {
+    path: string;
+    kind: InputPolicyKind;
+};
+export type InputPolicyDenied = InputPolicyEntry & {
+    reason: string;
+};
+export type InputPolicyReportV0 = {
+    policy_version: "v0";
+    found: InputPolicyEntry[];
+    denied: InputPolicyDenied[];
+    allowed: InputPolicyEntry[];
+    opts: {
+        strict: boolean;
+        include_local: boolean;
+    };
+    ok: boolean;
+    exit_code_recommended: 0 | 2;
+};
+type ScanOpts = {
+    strict: boolean;
+    include_local: boolean;
+};
+export declare function scanInputPolicyV0(projectRoot: string, opts: ScanOpts): Promise<InputPolicyReportV0>;
+export {};

package/dist/input_policy_v0.js

@@ -0,0 +1,76 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+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;
+}
+function classify(relPath) {
+    const rel = relPath.replace(/\\/g, "/");
+    const base = path.posix.basename(rel);
+    if (rel.endsWith("/.claude/settings.local.json") || base === "settings.local.json") {
+        return "claude_settings_local";
+    }
+    if (base === "CLAUDE.local.md" || base.includes(".local.")) {
+        return "local_file";
+    }
+    if (base === ".env" || base.startsWith(".env.")) {
+        return "env_file";
+    }
+    if (base.startsWith("id_rsa") || base.endsWith(".pem") || base.endsWith(".key")) {
+        return "private_key_like";
+    }
+    return "other";
+}
+export async function scanInputPolicyV0(projectRoot, opts) {
+    const absFiles = await listFilesRec(projectRoot);
+    const found = [];
+    const denied = [];
+    const allowed = [];
+    for (const abs of absFiles) {
+        const rel = path.relative(projectRoot, abs).replace(/\\/g, "/");
+        const kind = classify(rel);
+        const entry = { path: rel, kind };
+        found.push(entry);
+        if (kind === "env_file") {
+            denied.push({ ...entry, reason: "env_files_not_allowed" });
+        }
+        else if (kind === "private_key_like") {
+            denied.push({ ...entry, reason: "private_keys_not_allowed" });
+        }
+        else if (kind === "claude_settings_local") {
+            denied.push({ ...entry, reason: "settings_local_not_allowed" });
+        }
+        else if (kind === "local_file") {
+            if (opts.include_local)
+                allowed.push(entry);
+            else
+                denied.push({ ...entry, reason: "local_files_not_allowed" });
+        }
+        else {
+            allowed.push(entry);
+        }
+    }
+    const ok = denied.length === 0;
+    const exit_code_recommended = !ok && opts.strict ? 2 : 0;
+    return {
+        policy_version: "v0",
+        found,
+        denied,
+        allowed,
+        opts,
+        ok,
+        exit_code_recommended,
+    };
+}

package/dist/lint_v0.d.ts

@@ -0,0 +1,18 @@
+export type LintIssue = {
+    code: string;
+    message: string;
+    path?: string;
+};
+export type LintReportV0 = {
+    profile_version: "v0";
+    ok: boolean;
+    issues: LintIssue[];
+    summary: string;
+};
+type LintOptions = {
+    outRoot: string;
+    emitProfile: boolean;
+    mcpExpected: boolean;
+};
+export declare function lintV0(opts: LintOptions): Promise<LintReportV0>;
+export {};