mova-claude-import 0.1.1

package/schemas/ds.claude_import.mcp_servers_v0.schema.json

@@ -0,0 +1,47 @@
+{
+  "properties": {
+    "profile_version": {
+      "type": "string",
+      "const": "v0"
+    },
+    "servers": {
+      "type": "array",
+      "items": {
+        "required": [
+          "name",
+          "command"
+        ],
+        "properties": {
+          "command": {
+            "type": "string"
+          },
+          "args": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "env_keys": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "name": {
+            "type": "string"
+          }
+        },
+        "additionalProperties": false,
+        "type": "object"
+      }
+    }
+  },
+  "type": "object",
+  "$id": "ds.claude_import.mcp_servers_v0",
+  "required": [
+    "profile_version",
+    "servers"
+  ],
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false
+}

package/schemas/ds.claude_import.skills_catalog_v0.schema.json

@@ -0,0 +1,48 @@
+{
+  "properties": {
+    "profile_version": {
+      "type": "string",
+      "const": "v0"
+    },
+    "skills": {
+      "type": "array",
+      "items": {
+        "required": [
+          "skill_id",
+          "rel_dir",
+          "skill_md"
+        ],
+        "properties": {
+          "skill_md": {
+            "type": "string"
+          },
+          "assets": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "skill_id": {
+            "type": "string"
+          },
+          "rel_dir": {
+            "type": "string"
+          },
+          "title": {
+            "type": "string"
+          }
+        },
+        "additionalProperties": false,
+        "type": "object"
+      }
+    }
+  },
+  "type": "object",
+  "$id": "ds.claude_import.skills_catalog_v0",
+  "required": [
+    "profile_version",
+    "skills"
+  ],
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false
+}

package/src/anthropic_profile_v0.ts

@@ -0,0 +1,68 @@
+import { stableStringify } from "./stable_json.js";
+
+export const anthropicProfileV0RequiredFiles = [
+  "CLAUDE.md",
+  "MOVA.md",
+  ".claude/settings.json",
+  ".claude/commands/mova_context.md",
+  ".claude/commands/mova_lint.md",
+  ".claude/skills/mova-layer-v0/SKILL.md",
+] as const;
+
+export function getAnthropicProfileV0Files(): Record<string, string> {
+  return {
+    "CLAUDE.md": [
+      "# CLAUDE",
+      "",
+      "This profile is generated by mova-claude-import.",
+      "",
+      "Use MOVA.md for the project rules and structure.",
+      "Use .claude/commands/mova_context.md to build context.",
+      "Use .claude/commands/mova_lint.md to run structural lint.",
+      "",
+    ].join("\n"),
+    "MOVA.md": [
+      "# MOVA",
+      "",
+      "This is a clean Anthropic profile v0 output.",
+      "",
+      "Artifacts:",
+      "- mova/claude_import/v0/import_manifest.json",
+      "- mova/claude_import/v0/redaction_report.json",
+      "- mova/claude_import/v0/lint_report_v0.json",
+      "- mova/claude_import/v0/contracts/*.json",
+      "- mova/claude_import/v0/episode_import_run.json",
+      "",
+    ].join("\n"),
+    ".claude/settings.json": stableStringify({
+      profile_version: "v0",
+      commands: ["mova_context", "mova_lint"],
+      skills_root: ".claude/skills",
+    }) + "\n",
+    ".claude/commands/mova_context.md": [
+      "# mova_context",
+      "",
+      "Summarize the project based on MOVA.md and the contracts in",
+      "mova/claude_import/v0/contracts.",
+      "",
+    ].join("\n"),
+    ".claude/commands/mova_lint.md": [
+      "# mova_lint",
+      "",
+      "Run structural checks and report results from",
+      "mova/claude_import/v0/lint_report_v0.json.",
+      "",
+    ].join("\n"),
+    ".claude/skills/mova-layer-v0/SKILL.md": [
+      "---",
+      "name: mova-layer-v0",
+      "version: v0",
+      "---",
+      "",
+      "# mova-layer-v0",
+      "",
+      "Baseline behavior for the Anthropic profile v0 output.",
+      "",
+    ].join("\n"),
+  };
+}

package/src/claude_profile_scaffold_v0.ts

@@ -0,0 +1,117 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { stableStringify } from "./stable_json.js";
+import { MOVA_CONTROL_ENTRY_MARKER } from "./mova_overlay_v0.js";
+
+type ScaffoldFile = { rel: string; content: string };
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await fs.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function writeFile(absPath: string, content: string) {
+  await fs.mkdir(path.dirname(absPath), { recursive: true });
+  await fs.writeFile(absPath, content, "utf8");
+}
+
+function scaffoldFiles(): ScaffoldFile[] {
+  const settings = {
+    profile_version: "v0",
+    permissions: {
+      allow: [],
+      deny: [],
+      behavior: {
+        on_conflict: "deny_wins",
+        on_unknown: "report_only",
+      },
+    },
+    plugins: {
+      enable: true,
+      allowed_plugin_ids: [],
+      denied_plugin_ids: [],
+      behavior: {
+        on_unknown: "report_only",
+      },
+    },
+    hooks: {
+      enable: true,
+      definitions: [],
+      behavior: {
+        on_invalid_hook: "report_only",
+      },
+    },
+    claude_md: {
+      inject_control_entry: true,
+      marker: MOVA_CONTROL_ENTRY_MARKER,
+    },
+  };
+
+  return [
+    {
+      rel: "CLAUDE.md",
+      content: [
+        MOVA_CONTROL_ENTRY_MARKER,
+        "## MOVA Control Entry (v0)",
+        "",
+        "This is the canonical control entry marker for Claude Code.",
+        "",
+      ].join("\n"),
+    },
+    {
+      rel: ".claude/settings.json",
+      content: stableStringify(settings) + "\n",
+    },
+    {
+      rel: ".claude/settings.local.example.json",
+      content: stableStringify({
+        note: "Local settings are not committed; use this as a template.",
+      }) + "\n",
+    },
+    {
+      rel: ".claude/commands/example_command.md",
+      content: ["# example_command", "", "Write a brief project summary.", ""].join("\n"),
+    },
+    {
+      rel: ".claude/agents/example_agent.md",
+      content: ["# example_agent", "", "Role: reviewer", ""].join("\n"),
+    },
+    {
+      rel: ".claude/output-styles/example_style.md",
+      content: ["# example_style", "", "Style: concise, bullet-first.", ""].join("\n"),
+    },
+    {
+      rel: ".claude/hooks/example_hook.sh",
+      content: ["#!/usr/bin/env bash", "echo \"hook: dry check\""].join("\n") + "\n",
+    },
+    {
+      rel: ".mcp.json",
+      content: stableStringify({ servers: [] }) + "\n",
+    },
+    {
+      rel: "MOVA.md",
+      content: ["# MOVA", "", "Notes and operator instructions.", ""].join("\n"),
+    },
+  ];
+}
+
+export async function writeCleanClaudeProfileScaffoldV0(outDir: string) {
+  const files = scaffoldFiles();
+  for (const f of files) {
+    await writeFile(path.join(outDir, f.rel), f.content);
+  }
+}
+
+export async function ensureClaudeControlSurfacesV0(projectDir: string) {
+  const files = scaffoldFiles();
+  for (const f of files) {
+    const abs = path.join(projectDir, f.rel);
+    if (!(await exists(abs))) {
+      await writeFile(abs, f.content);
+    }
+  }
+}

package/src/cli.ts

@@ -0,0 +1,160 @@
+import { runImport } from "./run_import.js";
+import { initProfileV0 } from "./init_v0.js";
+import { controlPrefillV0 } from "./control_prefill_v0.js";
+import { controlCheckV0 } from "./control_check_v0.js";
+import { controlApplyV0 } from "./control_apply_v0.js";
+
+function getArg(name: string): string | undefined {
+  const idx = process.argv.indexOf(name);
+  if (idx === -1) return undefined;
+  return process.argv[idx + 1];
+}
+function hasFlag(name: string): boolean {
+  return process.argv.includes(name);
+}
+function usage(exitCode = 0) {
+  console.log([
+    "mova-claude-import (v0)",
+    "",
+    "Usage:",
+    "  mova-claude-import --project <dir> [--out <dir>] [--dry-run] [--strict] [--include-local] [--include-user-settings] [--no-emit-profile] [--no-emit-overlay] [--zip] [--zip-name <name>]",
+    "  mova-claude-import init --out <dir> [--zip]",
+    "  mova-claude-import control prefill --project <dir> --out <dir> [--include-local]",
+    "  mova-claude-import control check --project <dir> --profile <file>",
+    "  mova-claude-import control apply --project <dir> --profile <file> [--mode preview|apply]",
+    "",
+    "Notes:",
+    "  - CLAUDE.local.md and *.local.* are excluded unless --include-local",
+    "  - user-level settings are excluded unless --include-user-settings",
+    "  - profile emission is enabled by default; use --no-emit-profile to skip",
+    "  - overlay emission is enabled by default; use --no-emit-overlay to skip",
+    "  - zip export is disabled by default; use --zip to enable",
+    "  - init creates a clean Anthropic profile v0 scaffold",
+    "  - control commands run in preview by default",
+  ].join("\n"));
+  process.exit(exitCode);
+}
+
+if (hasFlag("--help") || hasFlag("-h")) usage(0);
+if (hasFlag("--version") || hasFlag("-v")) {
+  console.log("0.0.0");
+  process.exit(0);
+}
+
+const subcommand = process.argv[2];
+if (subcommand === "init") {
+  const out = getArg("--out");
+  if (!out) {
+    usage(2);
+    process.exit(2);
+  }
+  const emitZip = hasFlag("--zip");
+  initProfileV0(out, emitZip)
+    .then((res) => {
+      process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+      process.exit(0);
+    })
+    .catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+} else if (subcommand === "control") {
+  const action = process.argv[3];
+  const project = getArg("--project");
+  if (!project) {
+    usage(2);
+    process.exit(2);
+  }
+  if (action === "prefill") {
+    const out = getArg("--out");
+    if (!out) {
+      usage(2);
+      process.exit(2);
+    }
+    controlPrefillV0(project, out)
+      .then((res) => {
+        console.log([
+          "control prefill: ok",
+          `profile: ${res.profile_path}`,
+          `report: ${res.report_path}`,
+        ].join("\n"));
+        process.exit(0);
+      })
+      .catch((err) => {
+        console.error(err);
+        process.exit(1);
+      });
+  } else if (action === "check") {
+    const profile = getArg("--profile");
+    if (!profile) {
+      usage(2);
+      process.exit(2);
+    }
+    const out = getArg("--out") || project;
+    controlCheckV0(project, profile, out)
+      .then((res) => {
+        console.log([
+          "control check: ok",
+          `plan: ${res.plan_path}`,
+          `summary: ${res.summary_path}`,
+        ].join("\n"));
+        process.exit(0);
+      })
+      .catch((err) => {
+        console.error(err);
+        process.exit(1);
+      });
+  } else if (action === "apply") {
+    const profile = getArg("--profile");
+    if (!profile) {
+      usage(2);
+      process.exit(2);
+    }
+    const out = getArg("--out") || project;
+    const mode = getArg("--mode");
+    controlApplyV0(project, profile, out, mode)
+      .then((res) => {
+        console.log([
+          "control apply: ok",
+          `report: ${res.report_path}`,
+        ].join("\n"));
+        process.exit(0);
+      })
+      .catch((err) => {
+        console.error(err);
+        process.exit(1);
+      });
+  } else {
+    usage(2);
+    process.exit(2);
+  }
+} else {
+  const project = getArg("--project");
+  if (!project) {
+    usage(2);
+    process.exit(2);
+  }
+
+  const out = getArg("--out") || project;
+  const emitProfile = !hasFlag("--no-emit-profile");
+  const emitOverlay = !hasFlag("--no-emit-overlay");
+  const emitZip = hasFlag("--zip");
+  const zipName = getArg("--zip-name");
+
+  runImport({
+    projectDir: project,
+    outDir: out,
+    includeLocal: hasFlag("--include-local"),
+    includeUserSettings: hasFlag("--include-user-settings"),
+    dryRun: hasFlag("--dry-run"),
+    strict: hasFlag("--strict"),
+    emitProfile,
+    emitOverlay,
+    emitZip,
+    zipName,
+  }).then((res) => {
+    process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+    if (typeof res.exit_code === "number") process.exit(res.exit_code);
+    process.exit(res.ok ? 0 : 1);
+  });
+}

package/src/cli_entry.ts

@@ -0,0 +1 @@
+import "./cli.js";

package/src/control_apply_v0.ts

@@ -0,0 +1,108 @@
+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";
+
+type ApplyResult = {
+  run_id: string;
+  report_path: string;
+};
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await fs.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(p: string) {
+  const raw = await fs.readFile(p, "utf8");
+  return JSON.parse(raw);
+}
+
+async function writeJson(p: string, obj: any) {
+  await fs.mkdir(path.dirname(p), { recursive: true });
+  await fs.writeFile(p, stableStringify(obj) + "\n", "utf8");
+}
+
+function computeRunId(parts: string[]): string {
+  return stableSha256(parts.join("|")).slice(0, 16);
+}
+
+function updateClaude(content: string, marker: string, block: string): string {
+  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: string,
+  profilePath: string,
+  outDir: string,
+  mode?: string
+): Promise<ApplyResult> {
+  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/src/control_check_v0.ts

@@ -0,0 +1,98 @@
+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";
+
+type CheckResult = {
+  run_id: string;
+  plan_path: string;
+  summary_path: string;
+};
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await fs.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(p: string) {
+  const raw = await fs.readFile(p, "utf8");
+  return JSON.parse(raw);
+}
+
+async function writeJson(p: string, obj: any) {
+  await fs.mkdir(path.dirname(p), { recursive: true });
+  await fs.writeFile(p, stableStringify(obj) + "\n", "utf8");
+}
+
+function computeRunId(parts: string[]): string {
+  return stableSha256(parts.join("|")).slice(0, 16);
+}
+
+export async function controlCheckV0(projectDir: string, profilePath: string, outDir: string): Promise<CheckResult> {
+  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/src/control_contracts_v0.ts

@@ -0,0 +1,26 @@
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+type ControlContractsV0 = {
+  claude_control_profile: any;
+  claude_control_mapping: any;
+  claude_control_vocab: any;
+  claude_control_precedence: any;
+};
+
+async function loadJson(relPath: string) {
+  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(): Promise<ControlContractsV0> {
+  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`),
+  };
+}