@mycodemap/mycodemap 0.5.0 → 0.5.1

package/scripts/rule-context.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+import path from 'node:path';
+
+const USAGE = 'Usage: node scripts/rule-context.mjs --files <path> [<path>...] --format json|prompt';
+const DEFAULT_VERIFY_COMMANDS = ['python3 scripts/validate-rules.py code --report-only'];
+
+const ROUTES = [
+  {
+    matches: filePath => filePath.endsWith('.test.ts'),
+    rules: ['docs/rules/testing.md'],
+  },
+  {
+    matches: filePath => /^src\/interface\//.test(filePath),
+    rules: ['docs/rules/architecture-guardrails.md'],
+  },
+  {
+    matches: filePath => /^src\/(?:cli|domain|server|infrastructure)\//.test(filePath),
+    rules: [
+      'docs/rules/code-quality-redlines.md',
+      'docs/rules/architecture-guardrails.md',
+    ],
+  },
+  {
+    matches: filePath =>
+      /^(?:docs\/|\.githooks\/|\.github\/workflows\/)/.test(filePath),
+    rules: [
+      'docs/rules/validation.md',
+      'docs/rules/engineering-with-codex-openai.md',
+    ],
+  },
+];
+
+function normalizeFilePath(filePath) {
+  const resolved = path.isAbsolute(filePath)
+    ? path.relative(process.cwd(), filePath)
+    : filePath;
+
+  return resolved.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function parseArgs(argv) {
+  const files = [];
+  let format = 'json';
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const current = argv[index];
+
+    if (current === '--files') {
+      index += 1;
+      while (index < argv.length && !argv[index].startsWith('--')) {
+        files.push(argv[index]);
+        index += 1;
+      }
+      index -= 1;
+      continue;
+    }
+
+    if (current === '--format') {
+      format = argv[index + 1] ?? '';
+      index += 1;
+      continue;
+    }
+
+    if (current === '--help' || current === '-h') {
+      console.log(USAGE);
+      process.exit(0);
+    }
+  }
+
+  if (files.length === 0 || (format !== 'json' && format !== 'prompt')) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  return {
+    files: files.map(normalizeFilePath),
+    format,
+  };
+}
+
+function inferScopedRules(files) {
+  const matchedRules = [];
+  const matchedFiles = [];
+
+  for (const filePath of files) {
+    const route = ROUTES.find(candidate => candidate.matches(filePath));
+    if (!route) {
+      continue;
+    }
+
+    matchedFiles.push(filePath);
+
+    for (const rulePath of route.rules) {
+      if (!matchedRules.includes(rulePath)) {
+        matchedRules.push(rulePath);
+      }
+
+      if (matchedRules.length === 2) {
+        return matchedRules.length === 0
+          ? { files, matchedFiles: [], matchedRules: [], verifyCommands: [] }
+          : {
+              files,
+              matchedFiles,
+              matchedRules,
+              verifyCommands: DEFAULT_VERIFY_COMMANDS,
+            };
+      }
+    }
+  }
+
+  return matchedRules.length === 0
+    ? { files, matchedFiles: [], matchedRules: [], verifyCommands: [] }
+    : {
+        files,
+        matchedFiles,
+        matchedRules,
+        verifyCommands: DEFAULT_VERIFY_COMMANDS,
+      };
+}
+
+function formatPrompt(result) {
+  if (result.matchedRules.length === 0) {
+    return 'No scoped rules inferred';
+  }
+
+  return [
+    'Only inject matched rules:',
+    ...result.matchedRules.map(rulePath => `- ${rulePath}`),
+    '',
+    'Verify after edits:',
+    ...result.verifyCommands.map(command => `- ${command}`),
+  ].join('\n');
+}
+
+const args = parseArgs(process.argv.slice(2));
+const result = inferScopedRules(args.files);
+
+if (args.format === 'prompt') {
+  console.log(formatPrompt(result));
+  process.exit(0);
+}
+
+console.log(
+  JSON.stringify(
+    {
+      files: result.files,
+      matchedFiles: result.matchedFiles,
+      matchedRules: result.matchedRules,
+      verifyCommands: result.verifyCommands,
+    },
+    null,
+    2,
+  ),
+);

package/scripts/smoke-sqlite-impact.mjs

@@ -0,0 +1,85 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const loadModule = async (relativePath) => import(pathToFileURL(path.join(repoRoot, relativePath)).href);
+const { SQLiteStorage } = await loadModule('dist/infrastructure/storage/adapters/SQLiteStorage.js');
+const { QueryHandler } = await loadModule('dist/server/handlers/QueryHandler.js');
+
+function createImpactFixture() {
+  return {
+    project: {
+      id: 'proj-smoke',
+      name: 'sqlite-impact-smoke',
+      rootPath: '/fixture',
+      createdAt: new Date('2026-04-15T00:00:00Z'),
+      updatedAt: new Date('2026-04-15T00:00:00Z'),
+    },
+    modules: [
+      {
+        id: 'core',
+        projectId: 'proj-smoke',
+        path: 'src/core.ts',
+        language: 'ts',
+        stats: { lines: 10, codeLines: 8, commentLines: 1, blankLines: 1 },
+      },
+      {
+        id: 'service',
+        projectId: 'proj-smoke',
+        path: 'src/service.ts',
+        language: 'ts',
+        stats: { lines: 10, codeLines: 8, commentLines: 1, blankLines: 1 },
+      },
+      {
+        id: 'api',
+        projectId: 'proj-smoke',
+        path: 'src/api.ts',
+        language: 'ts',
+        stats: { lines: 10, codeLines: 8, commentLines: 1, blankLines: 1 },
+      },
+    ],
+    symbols: [],
+    dependencies: [
+      { id: 'dep-1', sourceId: 'service', targetId: 'core', type: 'import' },
+      { id: 'dep-2', sourceId: 'api', targetId: 'service', type: 'import' },
+    ],
+  };
+}
+
+const rootDir = mkdtempSync(path.join(tmpdir(), 'codemap-sqlite-impact-smoke-'));
+const storage = new SQLiteStorage({ type: 'sqlite', databasePath: '.codemap/governance.sqlite' });
+
+try {
+  await storage.initialize(rootDir);
+  await storage.saveCodeGraph(createImpactFixture());
+  const handler = new QueryHandler(storage);
+  const result = await handler.analyzeImpact({ moduleId: 'core', depth: 3 });
+  const stats = storage.getGovernanceGraphRuntimeStats();
+
+  if (result.rootModule !== 'core') {
+    throw new Error(`unexpected root module: ${result.rootModule}`);
+  }
+
+  if (result.totalAffected !== 2 || result.maxDepth !== 2) {
+    throw new Error(`unexpected impact result: ${JSON.stringify(result)}`);
+  }
+
+  if (stats.cacheMode !== 'memory-eager') {
+    throw new Error(`expected memory-eager smoke path, got ${stats.cacheMode} (${stats.warning ?? 'no warning'})`);
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    smoke: 'sqlite-impact',
+    cacheMode: stats.cacheMode,
+    rootModule: result.rootModule,
+    affectedModules: result.affectedModules,
+    loadMs: stats.loadMs,
+    rssDeltaMb: stats.rssDeltaMb,
+  }, null, 2));
+} finally {
+  await storage.close();
+  rmSync(rootDir, { recursive: true, force: true });
+}

package/scripts/sync-analyze-docs.js

@@ -92,6 +92,7 @@ function renderCommandsAnalyzeIntentExamples() {
       title: '1. find - 查找符号 / 文本',
       commands: [
         'mycodemap analyze -i find -k "UnifiedResult"',
+        'mycodemap analyze -i find -k "SourceLocation" --json --structured',
         'mycodemap analyze -i find -t "src/orchestrator" -k "IntentRouter" --topK 20',
       ],
     },

package/scripts/tests/test_capability_report.py

@@ -0,0 +1,89 @@
+import contextlib
+import io
+import importlib.util
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+
+def load_capability_report_module():
+    module_path = Path(__file__).resolve().parents[1] / "capability-report.py"
+    spec = importlib.util.spec_from_file_location("capability_report", module_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Unable to load module from {module_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+class CapabilityReportTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.module = load_capability_report_module()
+
+    def test_required_fail_status(self):
+        def failing_runner(command, cwd, timeout):
+            return {
+                "available": True,
+                "returncode": 1,
+                "stdout": "",
+                "stderr": "failed",
+                "duration_ms": 8,
+            }
+
+        item = self.module.build_item(
+            "python3",
+            "required",
+            ["python3", "--version"],
+            cwd=Path("."),
+            timeout=10,
+            runner=failing_runner,
+        )
+
+        self.assertEqual(item["status"], "REQUIRED_FAIL")
+
+    def test_optional_disabled_status(self):
+        def missing_runner(command, cwd, timeout):
+            return {
+                "available": False,
+                "returncode": None,
+                "stdout": "",
+                "stderr": "missing",
+                "duration_ms": 5,
+            }
+
+        item = self.module.build_item(
+            "validate_rules",
+            "optional",
+            ["python3", "scripts/validate-rules.py", "code", "--report-only"],
+            cwd=Path("."),
+            timeout=10,
+            runner=missing_runner,
+        )
+
+        self.assertEqual(item["status"], "OPTIONAL_DISABLED")
+
+    def test_output_file_written(self):
+        fake_report = {
+            "version": 1,
+            "generated_at": "2026-04-19T00:00:00Z",
+            "summary": {"required": {"passed": 1, "failed": 0, "total": 1}},
+            "items": [{"name": "python3", "kind": "required", "status": "PASS"}],
+        }
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_path = Path(temp_dir) / "capability-report.json"
+            with contextlib.redirect_stdout(io.StringIO()):
+                exit_code = self.module.main(["--output", str(output_path)], report_builder=lambda: fake_report)
+
+            self.assertEqual(exit_code, 0)
+            self.assertTrue(output_path.exists())
+
+            payload = json.loads(output_path.read_text(encoding="utf-8"))
+            self.assertIn("summary", payload)
+            self.assertIn("items", payload)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/scripts/tests/test_rule_control_workflow.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import unittest
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+class RuleControlWorkflowTests(unittest.TestCase):
+    def test_rule_context_is_scoped(self):
+        result = subprocess.run(
+            [
+                "node",
+                "scripts/rule-context.mjs",
+                "--files",
+                "src/cli/index.ts",
+                "--format",
+                "json",
+            ],
+            cwd=ROOT,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+        payload = json.loads(result.stdout)
+        self.assertIn("docs/rules/code-quality-redlines.md", payload["matchedRules"])
+        self.assertNotIn("docs/rules/testing.md", payload["matchedRules"])
+
+    def test_execute_workflows_include_rule_context(self):
+        workflow_paths = [
+            ROOT / ".codex/get-shit-done/workflows/execute-phase.md",
+            ROOT / ".claude/get-shit-done/workflows/execute-phase.md",
+        ]
+
+        for workflow_path in workflow_paths:
+            content = workflow_path.read_text(encoding="utf-8")
+            self.assertIn("rule-context.mjs --files", content)
+            self.assertIn("<rule_context>", content)
+
+    def test_ci_contains_rule_backstop(self):
+        content = (ROOT / ".github/workflows/ci-gateway.yml").read_text(encoding="utf-8")
+        self.assertIn("Rule validation backstop", content)
+        self.assertIn("python3 scripts/validate-rules.py code", content)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/scripts/tests/test_validate_rules.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+import unittest
+from pathlib import Path
+
+
+def load_validate_rules_module():
+    module_path = Path(__file__).resolve().parents[1] / "validate-rules.py"
+    spec = importlib.util.spec_from_file_location("validate_rules", module_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Failed to load module from {module_path}")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+validate_rules = load_validate_rules_module()
+
+
+def make_check(level: str, status: str):
+    return validate_rules.make_check(
+        name=f"{level.lower()}-{status}",
+        level=level,
+        command=["echo", status],
+        status=status,
+        output=status,
+    )
+
+
+class ValidateRulesExitCodeTests(unittest.TestCase):
+    def test_exit_code_for_no_findings(self):
+        checks = [make_check("P0", "passed"), make_check("P1", "passed")]
+        self.assertEqual(validate_rules.resolve_exit_code(checks, report_only=False), 0)
+
+    def test_exit_code_for_p0(self):
+        checks = [make_check("P0", "failed"), make_check("P1", "passed")]
+        self.assertEqual(validate_rules.resolve_exit_code(checks, report_only=False), 1)
+
+    def test_exit_code_for_p1(self):
+        checks = [make_check("P0", "passed"), make_check("P1", "failed")]
+        self.assertEqual(validate_rules.resolve_exit_code(checks, report_only=False), 2)
+
+    def test_exit_code_for_p2(self):
+        checks = [make_check("P0", "passed"), make_check("P2", "failed")]
+        self.assertEqual(validate_rules.resolve_exit_code(checks, report_only=False), 3)
+
+    def test_exit_code_for_unavailable(self):
+        checks = [make_check("P0", "failed"), make_check("P1", "unavailable")]
+        self.assertEqual(validate_rules.resolve_exit_code(checks, report_only=False), 4)
+
+    def test_report_only_exits_zero(self):
+        checks = [make_check("P0", "failed"), make_check("P1", "unavailable")]
+        self.assertEqual(validate_rules.resolve_exit_code(checks, report_only=True), 0)
+
+    def test_report_status_values_are_runtime_only(self):
+        checks = [
+            make_check("P0", "passed"),
+            make_check("P1", "failed"),
+            make_check("P2", "unavailable"),
+        ]
+        report = validate_rules.build_report("all", checks, report_only=False)
+        self.assertEqual([check["level"] for check in report["checks"]], ["P0", "P1", "P2"])
+        self.assertSetEqual(
+            {check["status"] for check in report["checks"]},
+            {"passed", "failed", "unavailable"},
+        )
+
+    def test_arch_check_marks_missing_dist_as_unavailable(self):
+        missing_dist = Path("/tmp/validate-rules-missing-dist.js")
+        checks = validate_rules.execute_checks("arch", dist_cli_path=missing_dist)
+        self.assertEqual(len(checks), 1)
+        self.assertEqual(checks[0]["level"], "P0")
+        self.assertEqual(checks[0]["status"], "unavailable")
+
+
+if __name__ == "__main__":
+    unittest.main()