mova-claude-import 0.1.1

package/src/control_prefill_v0.ts

@@ -0,0 +1,74 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { stableStringify } from "./stable_json.js";
+import { loadControlContractsV0 } from "./control_contracts_v0.js";
+
+type PrefillResult = {
+  profile_path: 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");
+}
+
+export async function controlPrefillV0(projectDir: string, outDir: string): Promise<PrefillResult> {
+  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: any = {};
+  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/src/export_zip_v0.ts

@@ -0,0 +1,90 @@
+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";
+
+type ExportZipResult = {
+  zipAbsPath: string;
+  zipRelPath: string;
+  zipSha256: string;
+  files: string[];
+};
+
+const FIXED_MTIME = new Date(Date.UTC(2000, 0, 1, 0, 0, 0));
+
+function shouldExclude(rel: string): boolean {
+  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: string): Promise<string[]> {
+  const out: string[] = [];
+  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: string, abs: string): string {
+  return path.relative(root, abs).replace(/\\/g, "/");
+}
+
+async function sha256File(p: string): Promise<string> {
+  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: string, files: Array<{ abs: string; rel: string }>) {
+  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<void>((resolve, reject) => {
+    outStream.on("close", resolve);
+    outStream.on("error", reject);
+  });
+  zipfile.outputStream.pipe(outStream);
+  zipfile.end();
+  await done;
+}
+
+export async function createExportZipV0(outRoot: string, zipName?: string): Promise<ExportZipResult> {
+  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/src/index.ts

@@ -0,0 +1,29 @@
+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/src/init_v0.ts

@@ -0,0 +1,59 @@
+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";
+
+type InitResult = {
+  createdFiles: string[];
+  zipRelPath?: string;
+  zipSha256?: string;
+};
+
+async function writeTextFile(absPath: string, content: string) {
+  await fs.mkdir(path.dirname(absPath), { recursive: true });
+  await fs.writeFile(absPath, content, "utf8");
+}
+
+async function writeJsonFile(absPath: string, obj: any) {
+  await fs.mkdir(path.dirname(absPath), { recursive: true });
+  await fs.writeFile(absPath, stableStringify(obj) + "\n", "utf8");
+}
+
+export async function initProfileV0(outRoot: string, emitZip: boolean): Promise<InitResult> {
+  const createdFiles: string[] = [];
+  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: string | undefined;
+  let zipSha256: string | undefined;
+  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/src/input_policy_v0.ts

@@ -0,0 +1,103 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+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 };
+
+async function listFilesRec(dir: string): Promise<string[]> {
+  const out: string[] = [];
+  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: string): InputPolicyKind {
+  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: string, opts: ScanOpts): Promise<InputPolicyReportV0> {
+  const absFiles = await listFilesRec(projectRoot);
+  const found: InputPolicyEntry[] = [];
+  const denied: InputPolicyDenied[] = [];
+  const allowed: InputPolicyEntry[] = [];
+
+  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: 0 | 2 = !ok && opts.strict ? 2 : 0;
+
+  return {
+    policy_version: "v0",
+    found,
+    denied,
+    allowed,
+    opts,
+    ok,
+    exit_code_recommended,
+  };
+}

package/src/lint_v0.ts

@@ -0,0 +1,151 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { anthropicProfileV0RequiredFiles } from "./anthropic_profile_v0.js";
+import { stableStringify } from "./stable_json.js";
+
+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;
+};
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await fs.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listFilesRec(dir: string): Promise<string[]> {
+  const out: string[] = [];
+  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 extractFrontmatterName(body: string): string | null {
+  const match = body.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!match) return null;
+  const lines = match[1].split(/\r?\n/);
+  for (const line of lines) {
+    const m = line.match(/^name:\s*(.+)\s*$/);
+    if (m) return m[1].trim();
+  }
+  return null;
+}
+
+export async function lintV0(opts: LintOptions): Promise<LintReportV0> {
+  const issues: LintIssue[] = [];
+  const required = [
+    ...(opts.emitProfile ? anthropicProfileV0RequiredFiles : []),
+    "mova/claude_import/v0/import_manifest.json",
+    "mova/claude_import/v0/redaction_report.json",
+    "mova/claude_import/v0/contracts/instruction_profile_v0.json",
+    "mova/claude_import/v0/contracts/skills_catalog_v0.json",
+    "mova/claude_import/v0/contracts/mcp_servers_v0.json",
+    "mova/claude_import/v0/episode_import_run.json",
+  ];
+
+  if (opts.mcpExpected && opts.emitProfile) {
+    required.push(".mcp.json");
+  }
+
+  for (const rel of required) {
+    const abs = path.join(opts.outRoot, rel);
+    if (!(await exists(abs))) {
+      issues.push({ code: "missing_file", message: "Required file is missing.", path: rel });
+    }
+  }
+
+  const settingsLocal = path.join(opts.outRoot, ".claude", "settings.local.json");
+  if (await exists(settingsLocal)) {
+    issues.push({ code: "settings_local_present", message: "settings.local.json must not be written.", path: ".claude/settings.local.json" });
+  }
+
+  const skillsRoot = path.join(opts.outRoot, ".claude", "skills");
+  if (await exists(skillsRoot)) {
+    const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+    for (const e of entries) {
+      const abs = path.join(skillsRoot, e.name);
+      if (e.isFile()) {
+        issues.push({ code: "skill_root_file", message: "Files are not allowed directly under .claude/skills.", path: `.claude/skills/${e.name}` });
+        continue;
+      }
+      if (e.isDirectory()) {
+        const skillMd = path.join(abs, "SKILL.md");
+        if (!(await exists(skillMd))) {
+          issues.push({ code: "missing_skill_md", message: "Skill directory is missing SKILL.md.", path: `.claude/skills/${e.name}/SKILL.md` });
+        }
+      }
+    }
+  }
+
+  const skillNameCounts = new Map<string, number>();
+  if (await exists(skillsRoot)) {
+    const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const skillMd = path.join(skillsRoot, e.name, "SKILL.md");
+      if (!(await exists(skillMd))) continue;
+      const body = await fs.readFile(skillMd, "utf8");
+      const name = extractFrontmatterName(body);
+      if (!name) continue;
+      skillNameCounts.set(name, (skillNameCounts.get(name) ?? 0) + 1);
+    }
+  }
+  for (const [name, count] of skillNameCounts.entries()) {
+    if (count > 1) {
+      issues.push({ code: "duplicate_skill_name", message: `Duplicate skill name in frontmatter: ${name}`, path: ".claude/skills" });
+    }
+  }
+
+  const jsonFiles = (await exists(opts.outRoot)) ? (await listFilesRec(opts.outRoot)).filter((p) => p.toLowerCase().endsWith(".json")) : [];
+  for (const abs of jsonFiles) {
+    if (abs.endsWith(`${path.sep}lint_report_v0.json`)) continue;
+    const rel = path.relative(opts.outRoot, abs).replace(/\\/g, "/");
+    const raw = await fs.readFile(abs, "utf8");
+    let parsed: any;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      issues.push({ code: "invalid_json", message: "JSON file failed to parse.", path: rel });
+      continue;
+    }
+    const normalized = stableStringify(parsed) + "\n";
+    if (raw !== normalized) {
+      issues.push({ code: "json_not_normalized", message: "JSON file is not normalized (sorted keys, 2 spaces, newline).", path: rel });
+    }
+  }
+
+  const ok = issues.length === 0;
+  const summary = ok ? "lint_v0: ok" : `lint_v0: ${issues.length} issue(s)`;
+  return {
+    profile_version: "v0",
+    ok,
+    issues,
+    summary,
+  };
+}

package/src/mova_overlay_v0.ts

@@ -0,0 +1,79 @@
+type OverlayParams = {
+  contractsDir: string;
+  artifactsDir: string;
+  instructionProfileFile: string;
+  skillsCatalogFile: string;
+  mcpServersFile: string;
+  lintReportFile: string;
+  qualityReportFile: string;
+  exportManifestFile: string;
+};
+
+export const MOVA_CONTROL_ENTRY_MARKER = "<!-- MOVA_CONTROL_ENTRY_V0 -->";
+
+export function buildMovaOverlayV0(params: OverlayParams): Record<string, string> {
+  const contractsDir = params.contractsDir;
+  const artifactsDir = params.artifactsDir;
+  const instruction = `${contractsDir}${params.instructionProfileFile}`;
+  const skills = `${contractsDir}${params.skillsCatalogFile}`;
+  const mcp = `${contractsDir}${params.mcpServersFile}`;
+  const lint = `${artifactsDir}${params.lintReportFile}`;
+  const quality = `${artifactsDir}${params.qualityReportFile}`;
+  const exportManifest = `${artifactsDir}${params.exportManifestFile}`;
+
+  return {
+    ".claude/commands/mova_context.md": [
+      "# mova_context",
+      "",
+      "Use MOVA contracts as source of truth:",
+      `- ${instruction}`,
+      `- ${skills}`,
+      `- ${mcp}`,
+      "",
+      "Then use CLAUDE.md and MOVA.md as narrative guides.",
+      "",
+    ].join("\n"),
+    ".claude/commands/mova_proof.md": [
+      "# mova_proof",
+      "",
+      "Proof/evidence files:",
+      `- ${lint}`,
+      `- ${quality}`,
+      `- ${exportManifest}`,
+      "",
+    ].join("\n"),
+    ".claude/skills/mova-control-v0/SKILL.md": [
+      "---",
+      "name: mova-control-v0",
+      "version: v0",
+      "---",
+      "",
+      "# mova-control-v0",
+      "",
+      "Rules:",
+      "- Use MOVA contracts first.",
+      "- Use evidence files for verification.",
+      "- Do not invent missing data.",
+      "",
+    ].join("\n"),
+  };
+}
+
+export function buildMovaControlEntryV0(params: OverlayParams): string {
+  const contractsDir = params.contractsDir;
+  const artifactsDir = params.artifactsDir;
+  return [
+    MOVA_CONTROL_ENTRY_MARKER,
+    "## MOVA Control Entry (v0)",
+    "",
+    "Source of truth (do this first):",
+    `- ${contractsDir}${params.instructionProfileFile}`,
+    `- ${contractsDir}${params.skillsCatalogFile}`,
+    `- ${contractsDir}${params.mcpServersFile}`,
+    "",
+    "Proof / evidence:",
+    `- ${artifactsDir}${params.qualityReportFile}`,
+    `- ${artifactsDir}${params.exportManifestFile}`,
+    "",
+  ].join("\n");
+}

package/src/mova_spec_bindings_v0.ts

@@ -0,0 +1,5 @@
+export const MOVA_SPEC_BINDINGS_V0 = {
+  instruction_profile_id: "https://mova.dev/schemas/ds.instruction_profile_core_v1.schema.json",
+  mcp_servers_id: "https://mova.dev/schemas/ds.runtime_binding_core_v1.schema.json",
+  core_schema_id: "https://mova.dev/schemas/ds.mova_schema_core_v1.schema.json",
+} as const;