mova-claude-import 0.1.1 → 0.1.2

package/test/control_demo_full_roundtrip.test.js

@@ -0,0 +1,92 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortKeys(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+async function normalizeJson(p) {
+  const raw = await fs.readFile(p, "utf8");
+  const parsed = JSON.parse(raw);
+  return JSON.stringify(sortKeys(parsed), null, 2);
+}
+
+test("control demo full roundtrip is deterministic", async () => {
+  const tmp = path.join(process.cwd(), ".tmp_test_full_roundtrip");
+  const fixture = path.join(process.cwd(), "fixtures", "pos", "claude_code_demo_full");
+  const proj = path.join(tmp, "proj");
+  const out1 = path.join(tmp, "out1");
+  const out2 = path.join(tmp, "out2");
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(tmp, { recursive: true });
+  await fs.cp(fixture, proj, { recursive: true });
+
+  await execFileP("node", ["dist/cli.js", "control", "prefill", "--project", proj, "--out", out1]);
+  await execFileP("node", ["dist/cli.js", "control", "prefill", "--project", proj, "--out", out2]);
+
+  const control1 = await normalizeJson(path.join(out1, "mova", "control_v0.json"));
+  const control2 = await normalizeJson(path.join(out2, "mova", "control_v0.json"));
+  assert.equal(control1, control2);
+
+  await execFileP("node", [
+    "dist/cli.js",
+    "control",
+    "apply",
+    "--project",
+    proj,
+    "--profile",
+    path.join(out1, "mova", "control_v0.json"),
+    "--mode",
+    "apply",
+    "--out",
+    out1,
+  ]);
+
+  const control = JSON.parse(await fs.readFile(path.join(out1, "mova", "control_v0.json"), "utf8"));
+  const { controlToSettingsV0 } = await import("../dist/control_v0.js");
+  const expectedSettingsPath = path.join(out1, "mova", "control_v0_settings_expected.json");
+  await fs.writeFile(expectedSettingsPath, JSON.stringify(controlToSettingsV0(control), null, 2));
+  const settingsExpected = await normalizeJson(expectedSettingsPath);
+  const settingsOut = await normalizeJson(path.join(proj, ".claude", "settings.json"));
+  assert.equal(settingsOut, settingsExpected);
+
+  const mcpOut = await normalizeJson(path.join(proj, ".mcp.json"));
+  const mcpExpected = await normalizeJson(path.join(fixture, ".mcp.json"));
+  assert.equal(mcpOut, mcpExpected);
+
+  const claude = await fs.readFile(path.join(proj, "CLAUDE.md"), "utf8");
+  assert.ok(claude.includes("MOVA_CONTROL_ENTRY_V0"));
+
+  await execFileP("node", [
+    "dist/cli.js",
+    "control",
+    "apply",
+    "--project",
+    proj,
+    "--profile",
+    path.join(out1, "mova", "control_v0.json"),
+    "--mode",
+    "apply",
+    "--out",
+    out1,
+  ]);
+
+  const settingsOut2 = await normalizeJson(path.join(proj, ".claude", "settings.json"));
+  const mcpOut2 = await normalizeJson(path.join(proj, ".mcp.json"));
+  assert.equal(settingsOut, settingsOut2);
+  assert.equal(mcpOut, mcpOut2);
+});

package/test/control_surface_coverage_v0.test.js

@@ -0,0 +1,36 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { runControlSurfaceCoverageV0 } from "../dist/control_surface_coverage_v0.js";
+
+const execFileP = promisify(execFile);
+
+test("control surface coverage reaches 100%", async () => {
+  const tmp = path.join(process.cwd(), ".tmp_test_surface_coverage");
+  const proj = path.join(tmp, "proj");
+  const out = path.join(tmp, "out");
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(tmp, { recursive: true });
+
+  const fixture = path.join(process.cwd(), "fixtures", "pos", "claude_code_demo_full");
+  await fs.cp(fixture, proj, { recursive: true });
+
+  await execFileP("node", ["dist/cli.js", "control", "prefill", "--project", proj, "--out", out]);
+
+  const showcaseRoot = process.env.SHOWCASE_ROOT || fixture;
+  const controlPath = path.join(out, "mova", "control_v0.json");
+  const exclusionsPath = path.join(process.cwd(), "control_surface_exclusions_v0.json");
+  const reportPath = path.join(tmp, "control_surface_coverage_report_v0.json");
+
+  const report = await runControlSurfaceCoverageV0({
+    showcaseRoot,
+    controlPath,
+    exclusionsPath,
+    reportPath,
+  });
+
+  assert.equal(report.coverage_percent, 100);
+});

package/test/control_v0_schema_validation.test.js

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+test("control check validates schema and fails on invalid control", async () => {
+  const tmp = path.join(process.cwd(), ".tmp_test_control_schema");
+  const proj = path.join(tmp, "proj");
+  const out = path.join(tmp, "out");
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(tmp, { recursive: true });
+
+  const fixture = path.join(process.cwd(), "fixtures", "pos", "claude_code_demo_full");
+  await fs.cp(fixture, proj, { recursive: true });
+
+  await execFileP("node", ["dist/cli.js", "control", "prefill", "--project", proj, "--out", out]);
+  await execFileP("node", [
+    "dist/cli.js",
+    "control",
+    "apply",
+    "--project",
+    proj,
+    "--profile",
+    path.join(out, "mova", "control_v0.json"),
+    "--mode",
+    "apply",
+    "--out",
+    out,
+  ]);
+
+  await execFileP("node", [
+    "dist/cli.js",
+    "control",
+    "check",
+    "--project",
+    proj,
+    "--profile",
+    path.join(out, "mova", "control_v0.json"),
+    "--out",
+    out,
+  ]);
+
+  const invalidControlPath = path.join(tmp, "invalid_control.json");
+  const invalid = JSON.parse(await fs.readFile(path.join(out, "mova", "control_v0.json"), "utf8"));
+  invalid.policy.mode = 123;
+  await fs.writeFile(invalidControlPath, JSON.stringify(invalid, null, 2));
+
+  let code = 0;
+  try {
+    await execFileP("node", [
+      "dist/cli.js",
+      "control",
+      "check",
+      "--project",
+      proj,
+      "--profile",
+      invalidControlPath,
+      "--out",
+      out,
+    ]);
+  } catch (err) {
+    code = err?.code ?? 1;
+  }
+  assert.equal(code, 2);
+});

package/test/init_v0.test.js

@@ -26,6 +26,7 @@ test("init v0 creates profile scaffold and optional zip", async () => {
   await assertExists(path.join(out, "CLAUDE.md"));
   await assertExists(path.join(out, ".claude", "settings.json"));
   await assertExists(path.join(out, ".claude", "skills", "mova-layer-v0", "SKILL.md"));
+  await assertExists(path.join(out, "mova", "control_v0.json"));
 
   const initManifestPath = path.join(out, "mova", "claude_import", "v0", "init_manifest_v0.json");
   const initManifest = JSON.parse(await fs.readFile(initManifestPath, "utf8"));
@@ -33,5 +34,13 @@ test("init v0 creates profile scaffold and optional zip", async () => {
   assert.ok(initManifest.zip_sha256);
   assert.ok(initManifest.zip_rel_path);
 
+  const controlPath = path.join(out, "mova", "control_v0.json");
+  const control = JSON.parse(await fs.readFile(controlPath, "utf8"));
+  assert.equal(control.version, "control_v0");
+  assert.equal(control.policy.mode, "report_only");
+  assert.equal(control.policy.hooks.on_invalid_hook, "report_only");
+  assert.equal(control.policy.permissions.on_unknown, "report_only");
+  assert.equal(control.policy.plugins.on_unknown, "report_only");
+
   await assertExists(path.join(out, initManifest.zip_rel_path));
 });

package/test/observability_writer_v0.test.js

@@ -0,0 +1,59 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+test("observability writer logs events without secrets", async () => {
+  const tmp = path.join(process.cwd(), ".tmp_test_observability");
+  const proj = path.join(tmp, "proj");
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(tmp, { recursive: true });
+
+  await execFileP("node", ["dist/cli.js", "init", "--out", proj]);
+  await execFileP("node", [
+    "dist/cli.js",
+    "control",
+    "apply",
+    "--project",
+    proj,
+    "--profile",
+    path.join(proj, "mova", "control_v0.json"),
+    "--mode",
+    "apply",
+    "--out",
+    proj,
+  ]);
+
+  const scriptPath = path.join(proj, ".claude", "hooks", "mova-observe.js");
+  await fs.stat(scriptPath);
+
+  await execFileP("node", [scriptPath, "--event", "PostToolUse"], {
+    env: {
+      ...process.env,
+      CLAUDE_PROJECT_DIR: proj,
+      CLAUDE_TOOL_NAME: "Bash",
+      CLAUDE_TOOL_STDOUT: "TOKEN=supersecret\nPLACEHOLDER=${TOKEN}\n",
+      CLAUDE_TOOL_STDERR: "sk-abcdef123456\n",
+    },
+  });
+
+  const episodesRoot = path.join(proj, ".mova", "episodes");
+  const runDirs = await fs.readdir(episodesRoot, { withFileTypes: true });
+  const runDir = runDirs.find((d) => d.isDirectory())?.name;
+  assert.ok(runDir, "expected run directory");
+
+  const eventsPath = path.join(episodesRoot, runDir, "events.jsonl");
+  const summaryPath = path.join(episodesRoot, runDir, "summary.json");
+  const events = (await fs.readFile(eventsPath, "utf8")).trim().split(/\r?\n/);
+  assert.ok(events.length >= 1);
+  const event = JSON.parse(events[0]);
+  assert.equal(event.event_type, "PostToolUse");
+  assert.ok(!JSON.stringify(event).includes("supersecret"));
+
+  const summary = JSON.parse(await fs.readFile(summaryPath, "utf8"));
+  assert.equal(summary.run_id, runDir);
+});

package/test/preset_safe_observable_v0.test.js

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+function hasHookCommand(hooks, needle) {
+  if (!Array.isArray(hooks)) return false;
+  for (const entry of hooks) {
+    for (const hook of entry?.hooks ?? []) {
+      if (typeof hook?.command === "string" && hook.command.includes(needle)) return true;
+    }
+  }
+  return false;
+}
+
+test("preset list includes safe_observable_v0", async () => {
+  const { stdout } = await execFileP("node", ["dist/cli.js", "preset", "list"]);
+  assert.ok(stdout.split(/\r?\n/).includes("safe_observable_v0"));
+});
+
+test("preset overlay applies assets and hooks", async () => {
+  const tmp = path.join(process.cwd(), ".tmp_test_preset");
+  const proj = path.join(tmp, "proj");
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(tmp, { recursive: true });
+
+  await execFileP("node", ["dist/cli.js", "init", "--out", proj]);
+  await execFileP("node", [
+    "dist/cli.js",
+    "control",
+    "apply",
+    "--preset",
+    "safe_observable_v0",
+    "--project",
+    proj,
+    "--mode",
+    "overlay",
+    "--out",
+    proj,
+  ]);
+
+  await fs.stat(path.join(proj, ".claude", "hooks", "skill-eval.sh"));
+  await fs.stat(path.join(proj, ".claude", "commands", "start.md"));
+  await fs.stat(path.join(proj, ".claude", "skills", "testing-patterns", "SKILL.md"));
+  await fs.stat(path.join(proj, ".claude", "hooks", "mova-observe.js"));
+
+  const settings = JSON.parse(await fs.readFile(path.join(proj, ".claude", "settings.json"), "utf8"));
+  assert.ok(hasHookCommand(settings?.hooks?.PostToolUse, "mova-observe.js"));
+  assert.ok(hasHookCommand(settings?.hooks?.PostToolUse, "--event PostToolUse"));
+  assert.ok(hasHookCommand(settings?.hooks?.UserPromptSubmit, "skill-eval.sh"));
+});

package/test/profile_v0_output.test.js

@@ -35,6 +35,7 @@ test("profile v0 output includes required files", async () => {
   await assertExists(path.join(out, ".claude", "commands", "mova_lint.md"));
   await assertExists(path.join(out, ".claude", "skills", "mova-layer-v0", "SKILL.md"));
   await assertExists(path.join(out, "mova", "claude_import", "v0", "lint_report_v0.json"));
+  await assertExists(path.join(out, "mova", "control_v0.json"));
   const versionPath = path.join(out, "mova", "claude_import", "v0", "VERSION.json");
   await assertExists(versionPath);
   const version = JSON.parse(await fs.readFile(versionPath, "utf8"));

package/test/scaffold_v0_output.test.js

@@ -31,6 +31,7 @@ test("init creates full scaffold surfaces", async () => {
   await assertExists(path.join(out, ".claude", "output-styles", "example_style.md"));
   await assertExists(path.join(out, ".claude", "hooks", "example_hook.sh"));
   await assertExists(path.join(out, ".mcp.json"));
+  await assertExists(path.join(out, "mova", "control_v0.json"));
 });
 
 test("control apply creates missing surfaces without erasing content", async () => {

package/tools/control_surface_coverage_v0.mjs

@@ -0,0 +1,27 @@
+import { runControlSurfaceCoverageV0 } from "../dist/control_surface_coverage_v0.js";
+
+const args = process.argv.slice(2);
+const getArg = (name) => {
+  const idx = args.indexOf(name);
+  if (idx === -1) return undefined;
+  return args[idx + 1];
+};
+
+const showcaseRoot = getArg("--showcase");
+const controlPath = getArg("--control");
+const exclusionsPath = getArg("--exclusions");
+const reportPath = getArg("--report");
+
+if (!showcaseRoot || !controlPath || !exclusionsPath || !reportPath) {
+  console.error("Usage: node tools/control_surface_coverage_v0.mjs --showcase <dir> --control <file> --exclusions <file> --report <file>");
+  process.exit(2);
+}
+
+const report = await runControlSurfaceCoverageV0({
+  showcaseRoot,
+  controlPath,
+  exclusionsPath,
+  reportPath,
+});
+
+process.stdout.write(JSON.stringify(report, null, 2) + "\n");

package/tools/smoke_v0.mjs

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+const tmp = path.join(process.cwd(), ".tmp_smoke");
+const out = path.join(tmp, "out");
+
+await fs.rm(tmp, { recursive: true, force: true });
+await fs.mkdir(out, { recursive: true });
+
+await execFileP("node", ["dist/cli.js", "init", "--out", out]);
+await execFileP("node", [
+  "dist/cli.js",
+  "control",
+  "apply",
+  "--preset",
+  "safe_observable_v0",
+  "--project",
+  out,
+  "--mode",
+  "overlay",
+  "--out",
+  out,
+]);
+
+await fs.stat(path.join(out, ".claude", "hooks", "skill-eval.sh"));
+await fs.stat(path.join(out, ".claude", "commands", "start.md"));
+await fs.stat(path.join(out, ".claude", "hooks", "mova-observe.js"));
+
+await fs.rm(tmp, { recursive: true, force: true });
+process.stdout.write("smoke: ok\n");

package/.tmp_test_control_apply/proj/.claude/agents/example_agent.md

@@ -1,3 +0,0 @@
-# example_agent
-
-Role: reviewer

package/.tmp_test_control_apply/proj/.claude/commands/example_command.md

@@ -1,3 +0,0 @@
-# example_command
-
-Write a brief project summary.

package/.tmp_test_control_apply/proj/.claude/hooks/example_hook.sh

@@ -1,2 +0,0 @@
-#!/usr/bin/env bash
-echo "hook: dry check"

package/.tmp_test_control_apply/proj/.claude/output-styles/example_style.md

@@ -1,3 +0,0 @@
-# example_style
-
-Style: concise, bullet-first.

package/.tmp_test_control_apply/proj/.claude/settings.json

@@ -1,30 +0,0 @@
-{
-  "claude_md": {
-    "inject_control_entry": true,
-    "marker": "<!-- MOVA_CONTROL_ENTRY_V0 -->"
-  },
-  "hooks": {
-    "behavior": {
-      "on_invalid_hook": "report_only"
-    },
-    "definitions": [],
-    "enable": true
-  },
-  "permissions": {
-    "allow": [],
-    "behavior": {
-      "on_conflict": "deny_wins",
-      "on_unknown": "report_only"
-    },
-    "deny": []
-  },
-  "plugins": {
-    "allowed_plugin_ids": [],
-    "behavior": {
-      "on_unknown": "report_only"
-    },
-    "denied_plugin_ids": [],
-    "enable": true
-  },
-  "profile_version": "v0"
-}

package/.tmp_test_control_apply/proj/.claude/settings.local.example.json

@@ -1,3 +0,0 @@
-{
-  "note": "Local settings are not committed; use this as a template."
-}

package/.tmp_test_control_apply/proj/.mcp.json

@@ -1,3 +0,0 @@
-{
-  "servers": {}
-}

package/.tmp_test_control_apply/proj/CLAUDE.md

@@ -1,13 +0,0 @@
-<!-- MOVA_CONTROL_ENTRY_V0 -->
-## MOVA Control Entry (v0)
-
-Source of truth (do this first):
-- 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
-
-Proof / evidence:
-- mova/claude_import/v0/quality_report_v0.json
-- mova/claude_import/v0/export_manifest_v0.json
-
-Hello

package/.tmp_test_control_apply/proj/MOVA.md

@@ -1,3 +0,0 @@
-# MOVA
-
-Notes and operator instructions.

package/.tmp_test_control_check/proj/.mcp.json

@@ -1 +0,0 @@
-{"servers":[]}

package/.tmp_test_control_check/proj/CLAUDE.md

@@ -1 +0,0 @@
-Hello

package/.tmp_test_control_prefill/out1/claude_control_profile_v0.json

@@ -1,114 +0,0 @@
-{
-  "anthropic": {
-    "claude_md": {
-      "description": "Политика вставки управляющего блока MOVA и позиционирование его в CLAUDE.md.",
-      "inject_control_entry": true,
-      "marker": "<!-- MOVA_CONTROL_ENTRY_V0 -->",
-      "paths": {
-        "local": "CLAUDE.local.md",
-        "project_alt": ".claude/CLAUDE.md",
-        "project_primary": "CLAUDE.md"
-      }
-    },
-    "hooks": {
-      "behavior": {
-        "on_invalid_hook": "report_only"
-      },
-      "definitions": [],
-      "description": "Крючки (hooks) Claude Code, если используются в проекте/плагинах.",
-      "enable": true
-    },
-    "mcp": {
-      "description": "Подключения MCP серверов и правила по переменным окружения.",
-      "env_expansion_policy": {
-        "allow_defaults_syntax": true,
-        "on_missing_var": "report_only",
-        "require_all_vars": false
-      },
-      "servers": []
-    },
-    "permissions": {
-      "allow": [],
-      "behavior": {
-        "on_conflict": "deny_wins",
-        "on_unknown": "report_only"
-      },
-      "deny": [],
-      "description": "Правила allow/deny (в стиле Claude Code) для действий и инструментов."
-    },
-    "plugins": {
-      "allowed_plugin_ids": [],
-      "behavior": {
-        "on_unknown": "report_only"
-      },
-      "denied_plugin_ids": [],
-      "description": "Политика использования плагинов/команд. На v0 — только реестр намерений и отчёты.",
-      "enable": true
-    },
-    "scopes_enabled": {
-      "local": true,
-      "managed": false,
-      "project": true,
-      "user": true
-    }
-  },
-  "apply": {
-    "backup_before_write": true,
-    "behavior": {
-      "on_parse_error": "report_only",
-      "on_unwritable_target": "report_only"
-    },
-    "default_apply_mode": "preview",
-    "default_target": "project_only",
-    "description": "Настройки операции apply (разнос из профиля в файлы Claude Code).",
-    "write_scopes": {
-      "local": false,
-      "project": true,
-      "user": false
-    }
-  },
-  "id": "ds.claude_control_profile_v0",
-  "kind": "ds",
-  "mode": "report_only",
-  "mova": {
-    "export": {
-      "description": "Экспорт zip для передачи/архивации результата.",
-      "emit_export_manifest": true,
-      "emit_zip": false,
-      "zip_name": "export.zip"
-    },
-    "observability": {
-      "artifact_root": "mova/claude_import/v0",
-      "description": "Артефакты наблюдаемости и доказательности. Включены по умолчанию.",
-      "emit_apply_report": true,
-      "emit_manifest": true,
-      "emit_policy_report": true,
-      "emit_quality_report": true,
-      "emit_version_anchor": true
-    },
-    "overlay": {
-      "description": "MOVA Control Overlay — добавляет понятный блок управления и ссылки на отчёты.",
-      "emit": true
-    },
-    "premium": {
-      "description": "Премиум-блоки по умолчанию выключены. Включаются пользователем, если он подключает соответствующие пакеты/дверь.",
-      "proofkits": {
-        "enabled": false,
-        "selected": []
-      },
-      "tool_door": {
-        "auth_ref": "",
-        "enabled": false,
-        "endpoint": "",
-        "policy_profile_id": ""
-      }
-    }
-  },
-  "notes": [
-    "Единая точка управления контролем Claude Code + MOVA слой наблюдаемости.",
-    "По умолчанию НЕ ломает работу: формирует отчёты и подсказки. Жёсткое применение/запреты включаются явно пользователем.",
-    "Этот профиль можно заполнить вручную или получить prefill через импорт существующей папки Claude."
-  ],
-  "title": "Claude Control Profile v0",
-  "version": "0.1.0"
-}

package/.tmp_test_control_prefill/out1/prefill_report_v0.json

@@ -1,13 +0,0 @@
-{
-  "applied": {
-    "mcp_servers": true
-  },
-  "found": {
-    "mcp_json": true,
-    "settings_json": false,
-    "settings_local_json": false
-  },
-  "profile_path": "D:\\Projects_Clean\\mova-claude-import\\.tmp_test_control_prefill\\out1\\claude_control_profile_v0.json",
-  "profile_version": "v0",
-  "project_dir": "D:\\Projects_Clean\\mova-claude-import\\fixtures\\pos\\control_basic_project"
-}