@akanjs/cli 2.4.0 → 2.4.1-rc.1

package/index-8rc0bm04.js

@@ -0,0 +1,514 @@
+// @bun
+import {
+  workflowRunArtifactPath,
+  workflowSyncDir
+} from "./index-h6ca6qg0.js";
+import {
+  AppExecutor,
+  LibExecutor
+} from "./index-a6sbyy0b.js";
+import {
+  FileSys
+} from "./index-61keag0s.js";
+
+// pkgs/@akanjs/devkit/akanContext.ts
+import { readdir } from "fs/promises";
+import path from "path";
+import { capitalize } from "akanjs/common";
+var resourceList = [
+  { uri: "akan://docs/framework", name: "Akan framework guide", mimeType: "text/markdown" },
+  { uri: "akan://guidelines/framework", name: "Framework guideline", mimeType: "text/markdown" },
+  { uri: "akan://guidelines/modelSignal", name: "Model signal guideline", mimeType: "text/markdown" },
+  { uri: "akan://workspace/summary", name: "Workspace summary", mimeType: "application/json" },
+  { uri: "akan://workspace/apps", name: "Workspace apps", mimeType: "application/json" },
+  { uri: "akan://workspace/modules", name: "Workspace modules", mimeType: "application/json" }
+];
+var cursorMcpConfigPath = ".cursor/mcp.json";
+var claudeMcpConfigPath = ".mcp.json";
+var codexMcpConfigPath = ".codex/config.toml";
+var akanMcpInstallTargets = ["cursor", "claude", "codex"];
+var akanMcpInstallConfigPaths = {
+  cursor: cursorMcpConfigPath,
+  claude: claudeMcpConfigPath,
+  codex: codexMcpConfigPath
+};
+var cursorWorkspaceFolder = "$" + "{workspaceFolder}";
+var claudeProjectDir = "$CLAUDE_PROJECT_DIR";
+var akanMcpCommand = (mode, { cd } = {}) => cd ? `cd "${cd}" && akan mcp --mode ${mode}` : `akan mcp --mode ${mode}`;
+var createAkanCursorMcpServer = (mode = "readonly") => ({
+  type: "stdio",
+  command: "bash",
+  args: ["-lc", akanMcpCommand(mode, { cd: cursorWorkspaceFolder })]
+});
+var createAkanClaudeMcpServer = (mode = "readonly") => ({
+  type: "stdio",
+  command: "bash",
+  args: ["-lc", akanMcpCommand(mode, { cd: claudeProjectDir })]
+});
+var createAkanMcpServer = (target, mode = "readonly") => target === "cursor" ? createAkanCursorMcpServer(mode) : createAkanClaudeMcpServer(mode);
+var akanCursorMcpServer = createAkanCursorMcpServer();
+var codexMcpServerTableHeader = "[mcp_servers.akan]";
+var createAkanCodexMcpServerBlock = (mode = "readonly") => `${codexMcpServerTableHeader}
+command = "bash"
+args = ["-lc", "${akanMcpCommand(mode)}"]
+`;
+var codexAkanTablePattern = /^\[mcp_servers\.akan\][^\n]*\n(?:(?!\[)[^\n]*(?:\n|$))*/m;
+var upsertCodexMcpServerBlock = (existing, block, { force = false } = {}) => {
+  const nextBlock = block.endsWith(`
+`) ? block : `${block}
+`;
+  const match = existing.match(codexAkanTablePattern);
+  if (!match) {
+    if (!existing.trim())
+      return nextBlock;
+    return `${existing.replace(/\s*$/, "")}
+
+${nextBlock}`;
+  }
+  if (match[0].trim() === nextBlock.trim())
+    return existing;
+  if (!force)
+    throw new Error(`${codexMcpConfigPath} already has an "akan" MCP server. Re-run with --force to overwrite it.`);
+  const start = match.index ?? 0;
+  const before = existing.slice(0, start);
+  const after = existing.slice(start + match[0].length);
+  const separator = after && !after.startsWith(`
+`) ? `
+` : "";
+  return `${before}${nextBlock}${separator}${after}`;
+};
+var renderDoctorText = (result) => {
+  const lines = [`Akan doctor status: ${result.status}`];
+  if (result.diagnostics.length === 0) {
+    lines.push("", "No Akan workspace diagnostics found.");
+  } else {
+    lines.push("", ...result.diagnostics.map((diagnostic) => [
+      `[${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`,
+      diagnostic.path ? `  ${diagnostic.path}` : ""
+    ].filter(Boolean).join(`
+`)));
+  }
+  lines.push("", "Generated file freshness:", `Status: ${result.generatedFilesFreshness.status}`, result.generatedFilesFreshness.message, `Refresh: ${result.generatedFilesFreshness.refreshCommand}`, "", "Repair actions:", ...result.repairActions.length ? result.repairActions.map((action) => `- ${action.command}`) : ["- none"], "", "Validation commands:", ...result.validationCommands.map((command) => `- ${command}`));
+  return `${lines.join(`
+`)}
+`;
+};
+var generatedFiles = [
+  "apps/*/client.ts",
+  "apps/*/server.ts",
+  "*/lib/cnst.ts",
+  "*/lib/db.ts",
+  "*/lib/dict.ts",
+  "*/lib/sig.ts",
+  "*/lib/srv.ts",
+  "*/lib/st.ts",
+  "*/lib/useClient.ts",
+  "*/lib/useServer.ts",
+  "*/lib/**/index.ts",
+  "*/ui/index.ts",
+  "*/webkit/index.ts",
+  "*/srvkit/index.ts",
+  "*/common/index.ts"
+];
+var validationCommands = [
+  "akan sync <app-or-lib>",
+  "akan lint <app-or-lib-or-pkg>",
+  "akan typecheck <app-name>",
+  "akan test <app-or-lib-or-pkg>",
+  "akan build <app-name>",
+  "akan doctor --strict --format json"
+];
+var unknownGeneratedFilesFreshness = {
+  status: "unknown",
+  message: "Run sync before validation so generated Akan files match the current source conventions.",
+  refreshCommand: "akan sync <app-or-lib>",
+  verifyingCommands: ["akan lint <app-or-lib-or-pkg>", "akan build <app-name>"]
+};
+var repairAction = (kind, command, reason, safeToRun) => ({
+  kind,
+  command,
+  reason,
+  safeToRun
+});
+var moduleShapeFiles = (module) => {
+  if (module.kind === "service") {
+    return [`${module.name}.dictionary.ts`, `${module.name}.service.ts`, `${module.name}.signal.ts`];
+  }
+  if (module.kind === "scalar")
+    return [`${module.name}.constant.ts`, `${module.name}.dictionary.ts`];
+  return [
+    `${module.name}.constant.ts`,
+    `${module.name}.dictionary.ts`,
+    `${module.name}.service.ts`,
+    `${module.name}.store.ts`,
+    `${module.name}.signal.ts`
+  ];
+};
+var constantFieldNames = (content) => [...content.matchAll(/\b([A-Za-z_$][\w$]*)\s*:\s*field\(/g)].map((match) => match[1]).filter(Boolean);
+var appRootAllowFiles = new Set([
+  "akan.app.json",
+  "akan.config.ts",
+  "capacitor.config.ts",
+  "client.ts",
+  "main.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json"
+]);
+var appRootAllowDirs = new Set([
+  ".akan",
+  "android",
+  "common",
+  "env",
+  "ios",
+  "lib",
+  "page",
+  "private",
+  "public",
+  "script",
+  "srvkit",
+  "ui",
+  "webkit"
+]);
+var safeReadDir = async (dirPath) => {
+  try {
+    return (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+};
+var safeReadText = async (filePath) => {
+  try {
+    return await FileSys.readText(filePath);
+  } catch {
+    return null;
+  }
+};
+var safeReadJson = async (filePath) => {
+  try {
+    return await FileSys.readJson(filePath);
+  } catch {
+    return null;
+  }
+};
+var isWorkflowPlan = (value) => typeof value === "object" && value !== null && ("schemaVersion" in value) && value.schemaVersion === 1 && ("mode" in value) && value.mode === "plan";
+var isWorkflowApplyReport = (value) => typeof value === "object" && value !== null && ("schemaVersion" in value) && value.schemaVersion === 1 && ("mode" in value) && (value.mode === "apply" || value.mode === "dry-run");
+var isWorkflowRunArtifact = (value) => typeof value === "object" && value !== null && ("schemaVersion" in value) && value.schemaVersion === 1;
+var planInputString = (plan, key) => {
+  const value = plan.inputs[key];
+  return typeof value === "string" ? value : "";
+};
+var expandWorkflowTarget = (target, plan) => {
+  const app = planInputString(plan, "app");
+  const module = planInputString(plan, "module");
+  const moduleClass = module ? capitalize(module) : "<Module>";
+  return target.replace(/^\*\//, app ? `apps/${app}/` : "").replaceAll("<module>", module || "<module>").replaceAll("<Module>", moduleClass);
+};
+var workflowPathsForPlan = (plan) => plan.predictedChanges.map((change) => expandWorkflowTarget(change.target, plan));
+var workflowPathsForArtifact = (artifact) => {
+  if (isWorkflowPlan(artifact))
+    return workflowPathsForPlan(artifact);
+  if (isWorkflowApplyReport(artifact)) {
+    return [
+      ...artifact.changedFiles.map((file) => file.path),
+      ...artifact.generatedFiles.map((file) => file.path),
+      ...workflowPathsForPlan(artifact.plan)
+    ];
+  }
+  if ("mode" in artifact && artifact.mode === "validate" && artifact.plan)
+    return workflowPathsForPlan(artifact.plan);
+  return [];
+};
+var loadWorkflowContextPaths = async (workspace, runIdOrPlan, changedFiles) => {
+  const paths = [...changedFiles];
+  if (!runIdOrPlan)
+    return paths;
+  const inputPath = path.isAbsolute(runIdOrPlan) ? runIdOrPlan : path.join(workspace.workspaceRoot, runIdOrPlan);
+  const artifact = await safeReadJson(inputPath) ?? await safeReadJson(path.join(workspace.workspaceRoot, workflowRunArtifactPath(runIdOrPlan)));
+  if (artifact && isWorkflowRunArtifact(artifact))
+    paths.push(...workflowPathsForArtifact(artifact));
+  return [...new Set(paths.filter(Boolean))];
+};
+var pathKey = (value) => value.replaceAll("\\", "/").replaceAll("*", "").replace(/<[^>]+>/g, "").replace(/\/+/g, "/").replace(/^\/|\/$/g, "");
+var isWorkflowRelatedDiagnostic = (diagnostic, workflowPaths) => {
+  if (!diagnostic.path)
+    return false;
+  const diagnosticPath = pathKey(diagnostic.path);
+  return workflowPaths.some((workflowPath) => {
+    const candidate = pathKey(workflowPath);
+    if (!candidate)
+      return false;
+    return diagnosticPath.startsWith(candidate) || candidate.startsWith(diagnosticPath) || diagnosticPath.includes(candidate);
+  });
+};
+var readGeneratedSyncStates = async (workspace) => {
+  const syncDir = path.join(workspace.workspaceRoot, workflowSyncDir);
+  const entries = await safeReadDir(syncDir);
+  const states = await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => safeReadJson(path.join(syncDir, entry.name))));
+  return states.filter((state) => !!state && state.schemaVersion === 1 && typeof state.target === "string" && typeof state.syncedAt === "string");
+};
+var generatedFreshnessFromStates = async (workspace) => {
+  const states = await readGeneratedSyncStates(workspace);
+  if (states.length === 0)
+    return unknownGeneratedFilesFreshness;
+  const targets = states.sort((a, b) => a.target.localeCompare(b.target)).map((state) => ({
+    target: state.target,
+    status: state.status === "passed" ? "fresh" : "stale",
+    lastSyncedAt: state.syncedAt,
+    runId: state.runId,
+    generatedFiles: state.generatedFiles.map((file) => file.path),
+    reason: state.status === "passed" ? `Generated files were refreshed by ${state.command}.` : `Last generated repair command failed: ${state.command}.`
+  }));
+  const lastFresh = targets.filter((target) => target.status === "fresh" && target.lastSyncedAt).sort((a, b) => (b.lastSyncedAt ?? "").localeCompare(a.lastSyncedAt ?? ""))[0];
+  return {
+    status: targets.some((target) => target.status === "fresh") ? "fresh" : "stale",
+    message: lastFresh ? `Generated files were refreshed for ${lastFresh.target} at ${lastFresh.lastSyncedAt}.` : "Generated sync state exists, but the last recorded repair did not pass.",
+    refreshCommand: "akan sync <app-or-lib>",
+    verifyingCommands: ["akan lint <app-or-lib-or-pkg>", "akan build <app-name>"],
+    targets
+  };
+};
+var parseAbstractSummary = (relativePath, content, includeContent) => {
+  if (content === null)
+    return { path: relativePath, exists: false, headings: [] };
+  const headings = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("#")).map((line) => line.replace(/^#+\s*/, "").trim()).filter(Boolean);
+  return {
+    path: relativePath,
+    exists: true,
+    title: headings[0],
+    headings: headings.slice(0, 8),
+    ...includeContent ? { content } : {}
+  };
+};
+var readFiles = async (dirPath) => (await safeReadDir(dirPath)).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+var getRelative = (workspace, absolutePath) => path.relative(workspace.workspaceRoot, absolutePath).replaceAll(path.sep, "/");
+var createModuleContext = async (workspace, sys, kind, folderName, moduleName, includeAbstractContent) => {
+  const modulePath = kind === "scalar" ? path.join(sys.cwdPath, "lib", "__scalar", moduleName) : path.join(sys.cwdPath, "lib", folderName);
+  const relativePath = getRelative(workspace, modulePath);
+  const abstractPath = `${relativePath}/${moduleName}.abstract.md`;
+  const abstractContent = await safeReadText(path.join(workspace.workspaceRoot, abstractPath));
+  return {
+    kind,
+    name: moduleName,
+    folderName,
+    sysName: sys.name,
+    sysType: sys.type,
+    path: relativePath,
+    abstract: parseAbstractSummary(abstractPath, abstractContent, includeAbstractContent),
+    files: await readFiles(modulePath)
+  };
+};
+var getSysModules = async (workspace, sys, {
+  includeAbstractContent = false,
+  module: moduleFilter
+} = {}) => {
+  const libPath = path.join(sys.cwdPath, "lib");
+  const entries = await safeReadDir(libPath);
+  const modules = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name === "__scalar")
+      continue;
+    if (entry.name.startsWith("__"))
+      continue;
+    if (entry.name.startsWith("_")) {
+      const serviceName = entry.name.replace(/^_+/, "");
+      if (moduleFilter && moduleFilter !== serviceName && moduleFilter !== entry.name)
+        continue;
+      if (!await FileSys.fileExists(path.join(libPath, entry.name, `${serviceName}.service.ts`)))
+        continue;
+      modules.push(await createModuleContext(workspace, sys, "service", entry.name, serviceName, includeAbstractContent));
+    } else {
+      if (moduleFilter && moduleFilter !== entry.name)
+        continue;
+      if (!await FileSys.fileExists(path.join(libPath, entry.name, `${entry.name}.constant.ts`)))
+        continue;
+      modules.push(await createModuleContext(workspace, sys, "domain", entry.name, entry.name, includeAbstractContent));
+    }
+  }
+  const scalarRoot = path.join(libPath, "__scalar");
+  for (const entry of await safeReadDir(scalarRoot)) {
+    if (!entry.isDirectory() || entry.name.startsWith("_"))
+      continue;
+    if (moduleFilter && moduleFilter !== entry.name)
+      continue;
+    if (!await FileSys.fileExists(path.join(scalarRoot, entry.name, `${entry.name}.constant.ts`)))
+      continue;
+    modules.push(await createModuleContext(workspace, sys, "scalar", entry.name, entry.name, includeAbstractContent));
+  }
+  return modules.sort((a, b) => `${a.sysName}:${a.path}`.localeCompare(`${b.sysName}:${b.path}`));
+};
+var getSysContext = async (workspace, type, name, options) => {
+  const sys = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
+  return {
+    type,
+    name,
+    path: `${type}s/${name}`,
+    hasConfig: await FileSys.fileExists(path.join(sys.cwdPath, "akan.config.ts")),
+    modules: await getSysModules(workspace, sys, {
+      includeAbstractContent: options.includeAbstractContent,
+      module: options.module
+    })
+  };
+};
+
+class AkanContextAnalyzer {
+  static async analyze(workspace, options = {}) {
+    const [appNames, libNames, pkgNames] = await workspace.getExecs();
+    const rootPackageJson = await safeReadJson(path.join(workspace.workspaceRoot, "package.json"));
+    const filteredApps = options.app ? appNames.filter((name) => name === options.app) : appNames;
+    const [apps, libs, pkgs] = await Promise.all([
+      Promise.all(filteredApps.map((name) => getSysContext(workspace, "app", name, options))),
+      Promise.all(libNames.map((name) => getSysContext(workspace, "lib", name, options))),
+      Promise.all(pkgNames.map(async (name) => {
+        const packageJson = await safeReadJson(path.join(workspace.workspaceRoot, "pkgs", name, "package.json"));
+        return {
+          name,
+          path: `pkgs/${name}`,
+          ...packageJson?.version ? { version: packageJson.version } : {}
+        };
+      }))
+    ]);
+    return {
+      schemaVersion: 1,
+      repoName: workspace.repoName,
+      root: workspace.workspaceRoot,
+      packageVersion: rootPackageJson?.dependencies?.akanjs ?? rootPackageJson?.devDependencies?.["@akanjs/devkit"],
+      apps,
+      libs,
+      pkgs,
+      generatedFiles,
+      validationCommands
+    };
+  }
+  static async doctor(workspace, {
+    strict = false,
+    runIdOrPlan = null,
+    changedFiles = []
+  } = {}) {
+    const context = await AkanContextAnalyzer.analyze(workspace);
+    const workflowPaths = await loadWorkflowContextPaths(workspace, runIdOrPlan, changedFiles);
+    const diagnostics = [];
+    const repairActions = [
+      repairAction("generated", "akan repair generated --app <app-or-lib>", "Refresh generated Akan files.", true),
+      repairAction("format", "akan repair format --target <app-or-lib-or-pkg>", "Run the formatter/linter repair path.", true)
+    ];
+    for (const app of context.apps) {
+      const appPath = path.join(workspace.workspaceRoot, app.path);
+      for (const entry of await safeReadDir(appPath)) {
+        const allowed = entry.isDirectory() ? appRootAllowDirs.has(entry.name) : appRootAllowFiles.has(entry.name);
+        if (!allowed) {
+          const action = repairAction("module-shape", `akan repair module-shape --app ${app.name}`, "Review app root shape and remove or move the unknown entry.", false);
+          diagnostics.push({
+            severity: "error",
+            code: "app-root-unknown-entry",
+            path: `${app.path}/${entry.name}`,
+            message: `Unexpected ${entry.isDirectory() ? "folder" : "file"} in app root: ${app.path}/${entry.name}`,
+            repairActions: [action]
+          });
+          repairActions.push(action);
+        }
+      }
+    }
+    for (const sys of [...context.apps, ...context.libs]) {
+      for (const module of sys.modules) {
+        if (!module.abstract.exists) {
+          const action = repairAction("module-shape", `akan repair module-shape --app ${sys.name} --module ${module.name}`, "Create the missing module abstract or inspect required source files.", false);
+          diagnostics.push({
+            severity: strict ? "error" : "warning",
+            code: "module-abstract-missing",
+            path: module.abstract.path,
+            message: `${capitalize(module.kind)} module ${sys.name}:${module.name} should include ${module.abstract.path}`,
+            repairActions: [action]
+          });
+          repairActions.push(action);
+        }
+        const missingFiles = moduleShapeFiles(module).filter((filename) => !module.files.includes(filename));
+        if (missingFiles.length) {
+          const action = repairAction("module-shape", `akan repair module-shape --app ${sys.name} --module ${module.name}`, "Review missing required module source files.", false);
+          diagnostics.push({
+            severity: "error",
+            code: "module-shape-invalid",
+            path: module.path,
+            message: `${capitalize(module.kind)} module ${sys.name}:${module.name} is missing required files: ${missingFiles.join(", ")}`,
+            repairActions: [action]
+          });
+          repairActions.push(action);
+        }
+        if (module.kind !== "service" && module.files.includes(`${module.name}.dictionary.ts`)) {
+          const constantPath = path.join(workspace.workspaceRoot, module.path, `${module.name}.constant.ts`);
+          const dictionaryPath = path.join(workspace.workspaceRoot, module.path, `${module.name}.dictionary.ts`);
+          const [constantContent, dictionaryContent] = await Promise.all([
+            safeReadText(constantPath),
+            safeReadText(dictionaryPath)
+          ]);
+          if (constantContent && dictionaryContent) {
+            for (const fieldName of constantFieldNames(constantContent)) {
+              if (new RegExp(`\\b${fieldName}\\s*:`).test(dictionaryContent))
+                continue;
+              const action = repairAction("dictionary", `akan repair dictionary --app ${sys.name} --module ${module.name}`, "Add missing dictionary labels for source constant fields.", false);
+              diagnostics.push({
+                severity: "warning",
+                code: "dictionary-label-missing",
+                path: `${module.path}/${module.name}.dictionary.ts`,
+                message: `Dictionary labels for ${sys.name}:${module.name}.${fieldName} were not found.`,
+                repairActions: [action]
+              });
+              repairActions.push(action);
+            }
+          }
+        }
+      }
+    }
+    const scopedDiagnostics = diagnostics.map((diagnostic) => ({
+      ...diagnostic,
+      scope: workflowPaths.length ? isWorkflowRelatedDiagnostic(diagnostic, workflowPaths) ? "workflow" : "baseline" : diagnostic.scope,
+      context: workflowPaths.length ? { ...diagnostic.context, paths: workflowPaths } : diagnostic.context
+    }));
+    const workflowDiagnostics = scopedDiagnostics.filter((diagnostic) => diagnostic.scope === "workflow");
+    const baselineDiagnostics = scopedDiagnostics.filter((diagnostic) => diagnostic.scope === "baseline");
+    return {
+      schemaVersion: 1,
+      repoName: context.repoName,
+      root: context.root,
+      strict,
+      status: scopedDiagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed",
+      diagnostics: scopedDiagnostics,
+      generatedFiles: context.generatedFiles,
+      generatedFilesFreshness: await generatedFreshnessFromStates(workspace),
+      validationCommands: context.validationCommands,
+      repairActions,
+      ...workflowPaths.length ? { baselineDiagnostics, workflowDiagnostics } : {}
+    };
+  }
+  static findModules(context, moduleName, { app = null } = {}) {
+    const modules = [...context.apps, ...context.libs].filter((sys) => !app || sys.name === app).flatMap((sys) => sys.modules);
+    return moduleName ? modules.filter((module) => module.name === moduleName || module.folderName === moduleName) : modules;
+  }
+  static renderMarkdown(context, { module: moduleName } = {}) {
+    const lines = [`# Akan Workspace Context`, "", `- Repo: ${context.repoName}`, `- Root: ${context.root}`];
+    if (context.packageVersion)
+      lines.push(`- Akan version: ${context.packageVersion}`);
+    lines.push("", "## Apps", ...context.apps.map((app) => `- ${app.name}: ${app.modules.length} module(s)`));
+    lines.push("", "## Libraries", ...context.libs.map((lib) => `- ${lib.name}: ${lib.modules.length} module(s)`));
+    lines.push("", "## Packages", ...context.pkgs.map((pkg) => `- ${pkg.name}${pkg.version ? ` (${pkg.version})` : ""}`));
+    const modules = AkanContextAnalyzer.findModules(context, moduleName);
+    lines.push("", "## Modules");
+    for (const module of modules) {
+      lines.push("", `### ${module.sysName}:${module.name} (${module.kind})`, `- Path: ${module.path}`);
+      lines.push(`- Abstract: ${module.abstract.exists ? module.abstract.path : "missing"}`);
+      if (module.abstract.exists && module.abstract.content)
+        lines.push("", module.abstract.content.trim(), "");
+      else if (module.abstract.headings.length)
+        lines.push(`- Abstract headings: ${module.abstract.headings.join(", ")}`);
+      lines.push(`- Files: ${module.files.join(", ") || "none"}`);
+    }
+    lines.push("", "## Validation", ...context.validationCommands.map((command) => `- \`${command}\``));
+    return `${lines.join(`
+`)}
+`;
+  }
+}
+
+export { resourceList, codexMcpConfigPath, akanMcpInstallTargets, akanMcpInstallConfigPaths, createAkanMcpServer, createAkanCodexMcpServerBlock, upsertCodexMcpServerBlock, renderDoctorText, AkanContextAnalyzer };