@happyvertical/smrt-dev-mcp 0.30.0

package/dist/index-DF0HSB_8.js

@@ -0,0 +1,1274 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { join, relative, resolve, dirname } from 'node:path';
+
+const SDK_PACKAGE_NAMES = /* @__PURE__ */ new Set([
+  "@happyvertical/ai",
+  "@happyvertical/cache",
+  "@happyvertical/documents",
+  "@happyvertical/email",
+  "@happyvertical/encryption",
+  "@happyvertical/files",
+  "@happyvertical/geo",
+  "@happyvertical/images",
+  "@happyvertical/jobs",
+  "@happyvertical/json",
+  "@happyvertical/logger",
+  "@happyvertical/messages",
+  "@happyvertical/ocr",
+  "@happyvertical/pdf",
+  "@happyvertical/projects",
+  "@happyvertical/repos",
+  "@happyvertical/secrets",
+  "@happyvertical/spider",
+  "@happyvertical/sql",
+  "@happyvertical/utils"
+]);
+const RELATIONSHIP_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "foreignKey",
+  "crossPackageRef",
+  "oneToMany",
+  "manyToMany"
+]);
+const WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".svelte-kit",
+  ".turbo",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+const STALE_PATTERNS = [
+  {
+    code: "stale-have-namespace",
+    pattern: new RegExp(`@${"have"}/`),
+    message: "Stale HappyVertical legacy namespace reference found"
+  },
+  {
+    code: "stale-smrt-core-namespace",
+    pattern: new RegExp(`@${"smrt"}/core`),
+    message: "Stale SMRT core namespace reference found"
+  },
+  {
+    code: "stale-field-helper-import",
+    pattern: /@happyvertical\/smrt-core\/fields/,
+    message: "Stale field-helper import path found"
+  },
+  {
+    code: "stale-docs-codex-command",
+    pattern: new RegExp(
+      `docs:${"codex"}|docs-${"codex"}|\\.${"codex"}|${"codex"}-command`,
+      "i"
+    ),
+    message: "Stale Codex-specific downstream-doc reference found"
+  }
+];
+async function buildKnowledgeIndex(options = {}) {
+  const rootDir = findProjectRoot(options.rootDir ?? process.cwd());
+  const includeDocs = options.includeDocs ?? true;
+  const packageDirs = discoverProjectPackageDirs(rootDir);
+  const packages = packageDirs.map(
+    (dir) => readKnowledgePackage(rootDir, dir, includeDocs)
+  );
+  packages.push(
+    ...discoverInstalledSdkPackages(rootDir, packageDirs, includeDocs)
+  );
+  const uniquePackages = dedupePackages(packages);
+  const scopedPackages = filterKnowledgePackages(uniquePackages, options);
+  const smrtPackages = scopedPackages.filter((pkg) => pkg.kind === "smrt");
+  const sdkPackages = scopedPackages.filter((pkg) => pkg.kind === "sdk");
+  return {
+    schemaVersion: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    rootDir,
+    packages: scopedPackages,
+    smrtPackages,
+    sdkPackages,
+    relationshipsV2: summarizeRelationshipsV2(scopedPackages)
+  };
+}
+async function checkKnowledgeFreshness(options = {}) {
+  const index = await buildKnowledgeIndex(options);
+  return checkKnowledgeFreshnessFromIndex(index, options);
+}
+async function checkKnowledgeFreshnessFromIndex(index, options = {}) {
+  const issues = [];
+  const changedFiles = options.changed ? getChangedFiles(index.rootDir) : void 0;
+  for (const pkg of index.packages.filter((item) => item.kind !== "sdk")) {
+    const packageJsonPath = join(pkg.directory, "package.json");
+    if (!pkg.hasAgentsMd) {
+      issues.push({
+        severity: "error",
+        code: "missing-agents-md",
+        message: "Workspace package is missing canonical AGENTS.md",
+        file: relative(index.rootDir, join(pkg.directory, "AGENTS.md")),
+        packageName: pkg.name
+      });
+    }
+    if (!pkg.hasClaudeMd) {
+      issues.push({
+        severity: "error",
+        code: "missing-claude-shim",
+        message: "Workspace package is missing CLAUDE.md compatibility shim",
+        file: relative(index.rootDir, join(pkg.directory, "CLAUDE.md")),
+        packageName: pkg.name
+      });
+    } else if (!pkg.hasClaudeShim) {
+      issues.push({
+        severity: "error",
+        code: "claude-not-shim",
+        message: "CLAUDE.md must contain only @AGENTS.md",
+        file: relative(index.rootDir, join(pkg.directory, "CLAUDE.md")),
+        packageName: pkg.name
+      });
+    }
+    for (const entry of pkg.files) {
+      if (entry === "dist" || entry.startsWith("dist/") || entry.includes("*")) {
+        continue;
+      }
+      const entryPath = join(pkg.directory, entry);
+      if (!existsSync(entryPath)) {
+        issues.push({
+          severity: "error",
+          code: "package-files-entry-missing",
+          message: `package.json files entry "${entry}" does not exist`,
+          file: relative(index.rootDir, packageJsonPath),
+          packageName: pkg.name
+        });
+      }
+    }
+    if (!pkg.files.includes("AGENTS.md")) {
+      issues.push({
+        severity: "error",
+        code: "package-files-missing-agents",
+        message: "package.json files allowlist must include AGENTS.md",
+        file: relative(index.rootDir, packageJsonPath),
+        packageName: pkg.name
+      });
+    }
+    if (!pkg.files.includes("CLAUDE.md")) {
+      issues.push({
+        severity: "error",
+        code: "package-files-missing-claude-shim",
+        message: "package.json files allowlist must include CLAUDE.md shim",
+        file: relative(index.rootDir, packageJsonPath),
+        packageName: pkg.name
+      });
+    }
+  }
+  for (const pkg of index.packages) {
+    issues.push(...checkDomainKnowledgeArtifact(index.rootDir, pkg));
+  }
+  issues.push(...findStalePatternIssues(index.rootDir, changedFiles));
+  const effectiveIssues = issues.map(
+    (issue) => issue.code.startsWith("stale-") ? {
+      ...issue,
+      severity: options.strict ? "error" : "warning"
+    } : issue
+  );
+  const errorCount = effectiveIssues.filter(
+    (i) => i.severity === "error"
+  ).length;
+  const warningCount = effectiveIssues.filter(
+    (i) => i.severity === "warning"
+  ).length;
+  return {
+    ok: errorCount === 0,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    rootDir: index.rootDir,
+    issueCount: effectiveIssues.length,
+    errorCount,
+    warningCount,
+    issues: effectiveIssues
+  };
+}
+function checkDomainKnowledgeArtifact(rootDir, pkg) {
+  const issues = [];
+  if (pkg.exportKeys.includes("./smrt-knowledge.json") && !pkg.hasDomainKnowledge) {
+    issues.push({
+      severity: "error",
+      code: "missing-domain-knowledge",
+      message: "package exports ./smrt-knowledge.json but no domain knowledge artifact was found",
+      file: relative(rootDir, join(pkg.directory, "package.json")),
+      packageName: pkg.name
+    });
+  }
+  if (!pkg.domainKnowledge || !pkg.domainKnowledgePath) {
+    return issues;
+  }
+  const hashes = pkg.domainKnowledge.sourceHashes ?? {};
+  const checks = [
+    {
+      key: "packageJson",
+      filePath: join(pkg.directory, "package.json"),
+      kind: "raw",
+      label: "package.json"
+    },
+    {
+      key: "agents",
+      filePath: existsSync(join(pkg.directory, "AGENTS.md")) ? join(pkg.directory, "AGENTS.md") : void 0,
+      kind: "raw",
+      label: "AGENTS.md"
+    },
+    {
+      key: "manifest",
+      filePath: domainSourceManifestPath(rootDir, pkg),
+      kind: "json",
+      label: "manifest"
+    }
+  ];
+  for (const check of checks) {
+    const expected = hashes[check.key];
+    if (!expected) continue;
+    if (!check.filePath || !existsSync(check.filePath)) {
+      issues.push({
+        severity: "error",
+        code: "domain-knowledge-source-missing",
+        message: `${check.label} source for smrt-knowledge.json is missing`,
+        file: pkg.domainKnowledgePath,
+        packageName: pkg.name
+      });
+      continue;
+    }
+    const actual = check.kind === "json" ? hashJsonFile(check.filePath) : hashFile(check.filePath);
+    if (actual !== expected) {
+      issues.push({
+        severity: "error",
+        code: "stale-domain-knowledge",
+        message: `${check.label} changed since smrt-knowledge.json was generated`,
+        file: pkg.domainKnowledgePath,
+        packageName: pkg.name
+      });
+    }
+  }
+  return issues;
+}
+function domainSourceManifestPath(rootDir, pkg) {
+  if (pkg.domainKnowledge?.sourceManifestPath) {
+    return join(pkg.directory, pkg.domainKnowledge.sourceManifestPath);
+  }
+  if (pkg.manifestPath) {
+    return join(rootDir, pkg.manifestPath);
+  }
+  return void 0;
+}
+async function diffKnowledgeIndex(options = {}) {
+  const index = await buildKnowledgeIndex({ rootDir: options.rootDir });
+  const base = options.base ?? "HEAD";
+  const changedFiles = getChangedFiles(index.rootDir, base);
+  const packageQuery = options.packageName ?? options.package;
+  const selected = selectPackagesForFiles(index, changedFiles).filter((pkg) => scopeAllowsPackage(pkg, options.scope)).filter(
+    (pkg) => packageQuery ? packageMatches(pkg, packageQuery.toLowerCase()) : true
+  );
+  const changedPackages = selected.map((pkg) => pkg.name);
+  return { base, changedFiles, changedPackages, index };
+}
+async function buildReviewContext(options = {}) {
+  const index = await buildKnowledgeIndex({ rootDir: options.rootDir });
+  const changedFiles = options.changedFiles ?? getChangedFiles(index.rootDir);
+  const selectedPackages = selectPackages(index, {
+    changedFiles,
+    text: [options.focus, options.documentation].filter(Boolean).join("\n"),
+    scope: options.scope,
+    packageName: options.packageName ?? options.package
+  });
+  const selectedSdkPackages = selectSdkPackages(
+    index,
+    selectedPackages,
+    [
+      options.focus,
+      options.documentation,
+      options.packageName ?? options.package
+    ],
+    {
+      scope: options.scope,
+      packageName: options.packageName ?? options.package
+    }
+  );
+  const deterministicFindings = findStalePatternIssues(
+    index.rootDir,
+    changedFiles.length > 0 ? changedFiles : void 0
+  ).concat(buildReviewFindings(index, changedFiles, selectedPackages));
+  return {
+    selectedPackages,
+    selectedSdkPackages,
+    deterministicFindings,
+    promptBundle: buildPromptBundle({
+      title: "SMRT code review",
+      task: "Review the changed SMRT code. Prioritize correctness, relationships-v2 invariants, tenancy, SDK usage, prompt/data safety, and stale documentation.",
+      index,
+      packages: selectedPackages,
+      sdkPackages: selectedSdkPackages,
+      sourceFiles: changedFiles,
+      extraContext: options.focus
+    })
+  };
+}
+async function smrtReview(options = {}) {
+  const context = await buildReviewContext(options);
+  const mode = options.mode ?? "both";
+  return {
+    mode,
+    selectedPackages: context.selectedPackages,
+    selectedSdkPackages: context.selectedSdkPackages,
+    ...mode !== "prompt-bundle" ? { deterministicFindings: context.deterministicFindings } : {},
+    ...mode !== "findings" ? { promptBundle: context.promptBundle } : {}
+  };
+}
+async function buildArchitectureContext(options = {}) {
+  const index = await buildKnowledgeIndex({ rootDir: options.rootDir });
+  const text = [options.idea, options.documentation, options.focus].filter(Boolean).join("\n");
+  const selectedPackages = selectPackages(index, {
+    text,
+    scope: options.scope,
+    packageName: options.packageName ?? options.package
+  });
+  const selectedSdkPackages = selectSdkPackages(
+    index,
+    selectedPackages,
+    [text, options.packageName ?? options.package],
+    {
+      scope: options.scope,
+      packageName: options.packageName ?? options.package
+    }
+  );
+  return {
+    selectedPackages,
+    selectedSdkPackages,
+    promptBundle: buildPromptBundle({
+      title: "SMRT architecture planning",
+      task: "Suggest the SMRT packages, HappyVertical SDK packages, object model, integration points, risks, and implementation slices for this project idea.",
+      index,
+      packages: selectedPackages,
+      sdkPackages: selectedSdkPackages,
+      sourceFiles: [],
+      extraContext: text
+    })
+  };
+}
+async function smrtArchitecture(options = {}) {
+  const context = await buildArchitectureContext(options);
+  const ideaText = [options.idea, options.documentation, options.focus].filter(Boolean).join("\n");
+  return {
+    ...context,
+    recommendations: buildArchitectureRecommendations(context, ideaText)
+  };
+}
+function renderKnowledgeIndexMarkdown(index) {
+  const lines = [
+    "# SMRT Knowledge Index",
+    "",
+    `Generated: ${index.generatedAt}`,
+    `Root: ${index.rootDir}`,
+    "",
+    "## Summary",
+    "",
+    `- SMRT packages: ${index.smrtPackages.length}`,
+    `- SDK packages: ${index.sdkPackages.length}`,
+    `- foreignKey fields: ${index.relationshipsV2.foreignKeyFields}`,
+    `- crossPackageRef fields: ${index.relationshipsV2.crossPackageRefFields}`,
+    `- junction collections: ${index.relationshipsV2.junctionCollections}`,
+    `- hierarchical objects: ${index.relationshipsV2.hierarchicalObjects}`,
+    `- polymorphic associations: ${index.relationshipsV2.polymorphicAssociations}`,
+    `- UUID columns: ${index.relationshipsV2.uuidColumns}`,
+    "",
+    "## Packages",
+    ""
+  ];
+  for (const pkg of index.packages) {
+    lines.push(`### ${pkg.name}`);
+    lines.push("");
+    lines.push(`- kind: ${pkg.kind}`);
+    lines.push(`- version: ${pkg.version}`);
+    lines.push(`- objects: ${pkg.objects.length}`);
+    lines.push(`- SMRT deps: ${pkg.smrtDependencies.join(", ") || "(none)"}`);
+    lines.push(`- SDK deps: ${pkg.sdkDependencies.join(", ") || "(none)"}`);
+    lines.push(`- exports: ${pkg.exportKeys.join(", ") || "(none)"}`);
+    lines.push(`- MCP tools: ${pkg.mcpTools.length}`);
+    lines.push(
+      `- domain knowledge: ${pkg.domainKnowledgePath ?? "(manifest fallback)"}`
+    );
+    lines.push(
+      `- docs: ${pkg.docSource ?? "(none)"}${pkg.hasClaudeShim ? " + CLAUDE.md shim" : ""}`
+    );
+    if (pkg.relationshipFeatures.length > 0) {
+      lines.push(`- relationships-v2: ${pkg.relationshipFeatures.join(", ")}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderFreshnessResult(result) {
+  const lines = [
+    result.ok ? "✓ SMRT knowledge is fresh" : "✗ SMRT knowledge has issues",
+    "",
+    `Root: ${result.rootDir}`,
+    `Errors: ${result.errorCount}`,
+    `Warnings: ${result.warningCount}`,
+    ""
+  ];
+  for (const issue of result.issues) {
+    const location = issue.file ? ` (${issue.file})` : "";
+    lines.push(
+      `- [${issue.severity.toUpperCase()}] ${issue.code}: ${issue.message}${location}`
+    );
+  }
+  return lines.join("\n");
+}
+function findProjectRoot(startDir) {
+  let current = resolve(startDir);
+  for (; ; ) {
+    if (existsSync(join(current, "pnpm-workspace.yaml")) && existsSync(join(current, "packages"))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) return resolve(startDir);
+    current = parent;
+  }
+}
+function discoverWorkspacePackageDirs(rootDir) {
+  const packagesDir = join(rootDir, "packages");
+  if (!existsSync(packagesDir)) return [];
+  return readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(packagesDir, entry.name)).filter((dir) => existsSync(join(dir, "package.json"))).sort();
+}
+function discoverProjectPackageDirs(rootDir) {
+  const workspaceDirs = discoverWorkspacePackageDirs(rootDir);
+  if (existsSync(join(rootDir, "package.json")) && hasLocalDomainArtifact(rootDir)) {
+    return [rootDir, ...workspaceDirs.filter((dir) => dir !== rootDir)];
+  }
+  return workspaceDirs;
+}
+function hasLocalDomainArtifact(rootDir) {
+  return [
+    join(rootDir, ".smrt", "smrt-knowledge.json"),
+    join(rootDir, ".smrt", "manifest.json"),
+    join(rootDir, "dist", "smrt-knowledge.json"),
+    join(rootDir, "dist", "manifest.json"),
+    join(rootDir, "src", "manifest", "smrt-knowledge.json"),
+    join(rootDir, "src", "manifest", "manifest.json")
+  ].some((path) => existsSync(path));
+}
+function discoverInstalledSdkPackages(rootDir, packageDirs, includeDocs) {
+  const scopeDirs = [
+    join(rootDir, "node_modules", "@happyvertical"),
+    ...packageDirs.map((dir) => join(dir, "node_modules", "@happyvertical"))
+  ];
+  return scopeDirs.filter(
+    (scopeDir, index, all) => existsSync(scopeDir) && all.indexOf(scopeDir) === index
+  ).flatMap(
+    (scopeDir) => readdirSync(scopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => {
+      const entryPath = join(scopeDir, entry.name);
+      try {
+        return lstatSync(entryPath).isSymbolicLink() ? realpathSync(entryPath) : entryPath;
+      } catch {
+        return entryPath;
+      }
+    })
+  ).filter((dir) => {
+    const pkg = readJson(join(dir, "package.json"));
+    return typeof pkg?.name === "string" && SDK_PACKAGE_NAMES.has(pkg.name) && !pkg.name.startsWith("@happyvertical/smrt-");
+  }).map((dir) => readKnowledgePackage(rootDir, dir, includeDocs));
+}
+function filterKnowledgePackages(packages, options) {
+  const packageQuery = options.packageName ?? options.package;
+  return packages.filter((pkg) => {
+    if (packageQuery && !packageMatches(pkg, packageQuery.toLowerCase())) {
+      return false;
+    }
+    switch (options.scope) {
+      case "local":
+        return pkg.kind !== "sdk" && !pkg.relativeDirectory.includes("node_modules");
+      case "package":
+        return pkg.kind !== "sdk";
+      case "sdk":
+        return pkg.kind === "sdk";
+      case "project":
+      case void 0:
+        return true;
+      default:
+        return true;
+    }
+  });
+}
+function readKnowledgePackage(rootDir, directory, includeDocs) {
+  const packageJson = readJson(join(directory, "package.json")) ?? {};
+  const dependencies = objectRecord(packageJson.dependencies);
+  const devDependencies = objectRecord(packageJson.devDependencies);
+  const peerDependencies = objectRecord(packageJson.peerDependencies);
+  const allDeps = { ...dependencies, ...devDependencies, ...peerDependencies };
+  const name = String(packageJson.name ?? directory);
+  const agentsPath = join(directory, "AGENTS.md");
+  const claudePath = join(directory, "CLAUDE.md");
+  const hasAgentsMd = existsSync(agentsPath);
+  const hasClaudeMd = existsSync(claudePath);
+  const claudeContent = hasClaudeMd ? readFileSync(claudePath, "utf8") : "";
+  const agentsContent = hasAgentsMd ? readFileSync(agentsPath, "utf8") : "";
+  const fallbackClaudeDoc = hasClaudeMd && claudeContent.trim() !== "@AGENTS.md" ? claudeContent : "";
+  const domainKnowledge = readDomainKnowledge(directory);
+  const docSource = hasAgentsMd ? "AGENTS.md" : fallbackClaudeDoc ? "CLAUDE.md" : null;
+  const manifest = readManifest(directory);
+  const objects = domainKnowledge ? readDomainKnowledgeObjects(domainKnowledge.content) : manifest ? readManifestObjects(manifest.content) : [];
+  const prompts = domainKnowledge ? readDomainKnowledgePrompts(domainKnowledge.content, directory, rootDir) : readPrompts(directory, rootDir);
+  const smrtDependencies = Object.keys(allDeps).filter((dep) => dep.startsWith("@happyvertical/smrt-")).sort();
+  const sdkDependencies = Object.keys(allDeps).filter((dep) => SDK_PACKAGE_NAMES.has(dep)).sort();
+  return {
+    name,
+    version: String(packageJson.version ?? "0.0.0"),
+    kind: packageKind(name),
+    directory,
+    relativeDirectory: relative(rootDir, directory),
+    files: Array.isArray(packageJson.files) ? packageJson.files : [],
+    exportKeys: exportKeys(packageJson.exports),
+    dependencies,
+    devDependencies,
+    peerDependencies,
+    smrtDependencies,
+    sdkDependencies,
+    hasAgentsMd,
+    hasClaudeMd,
+    hasClaudeShim: claudeContent.trim() === "@AGENTS.md",
+    docSource,
+    agentDoc: includeDocs ? domainKnowledge?.content.agentDoc || (hasAgentsMd ? agentsContent : fallbackClaudeDoc || void 0) : void 0,
+    hasDomainKnowledge: Boolean(domainKnowledge),
+    domainKnowledgePath: domainKnowledge?.path ? relative(rootDir, domainKnowledge.path) : void 0,
+    domainKnowledge: domainKnowledge?.content,
+    manifestPath: manifest?.path ? relative(rootDir, manifest.path) : void 0,
+    manifestVersion: typeof manifest?.content.version === "string" ? manifest.content.version : void 0,
+    objects,
+    prompts,
+    mcpTools: domainKnowledge ? domainMcpTools(domainKnowledge.content) : mcpTools(objects),
+    relationshipFeatures: relationshipFeatures(objects)
+  };
+}
+function readDomainKnowledge(directory) {
+  for (const path of [
+    join(directory, ".smrt", "smrt-knowledge.json"),
+    join(directory, "dist", "smrt-knowledge.json"),
+    join(directory, "src", "manifest", "smrt-knowledge.json")
+  ]) {
+    const content = readJson(path);
+    if (isDomainKnowledgeManifest(content)) {
+      return { path, content };
+    }
+  }
+  return null;
+}
+function isDomainKnowledgeManifest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  return record.schemaVersion === 1 && Array.isArray(record.objects);
+}
+function readManifest(directory) {
+  for (const path of [
+    join(directory, "src", "manifest", "manifest.json"),
+    join(directory, ".smrt", "manifest.json"),
+    join(directory, "dist", "manifest.json")
+  ]) {
+    const content = readJson(path);
+    if (content) return { path, content };
+  }
+  return null;
+}
+function readManifestObjects(manifest) {
+  const objects = objectRecord(manifest.objects);
+  return Object.values(objects).map((raw) => {
+    const item = raw;
+    const fields = objectRecord(item.fields);
+    const schemaColumns = objectRecord(item.schema?.columns);
+    const decoratorConfig = item.decoratorConfig;
+    const knowledgeFields = Object.entries(fields).map(([fieldName, field]) => {
+      const fieldInfo = field;
+      const columnName = camelToSnake(fieldName);
+      const column = schemaColumns[columnName];
+      return {
+        name: fieldName,
+        type: String(fieldInfo.type ?? "unknown"),
+        required: typeof fieldInfo.required === "boolean" ? fieldInfo.required : void 0,
+        related: typeof fieldInfo.related === "string" ? fieldInfo.related : void 0,
+        columnType: typeof column?.type === "string" ? column.type : void 0
+      };
+    });
+    return {
+      className: String(item.className ?? item.name ?? "Unknown"),
+      qualifiedName: typeof item.qualifiedName === "string" ? item.qualifiedName : void 0,
+      filePath: typeof item.filePath === "string" ? item.filePath : void 0,
+      extends: typeof item.extends === "string" ? item.extends : void 0,
+      collection: typeof item.collection === "string" ? item.collection : void 0,
+      mcpOperations: mcpOperations(item.decoratorConfig?.mcp),
+      tableName: typeof decoratorConfig?.tableName === "string" ? decoratorConfig.tableName : typeof item.schema?.tableName === "string" ? item.schema.tableName : void 0,
+      idColumnType: typeof schemaColumns.id?.type === "string" ? schemaColumns.id.type : void 0,
+      fields: knowledgeFields,
+      relationships: knowledgeFields.filter(
+        (field) => RELATIONSHIP_FIELD_TYPES.has(field.type)
+      ),
+      methods: Object.keys(objectRecord(item.methods)).sort()
+    };
+  });
+}
+function readDomainKnowledgeObjects(manifest) {
+  return manifest.objects.map((object) => ({
+    className: object.name,
+    qualifiedName: object.qualifiedName,
+    extends: object.extends,
+    collection: object.collection,
+    mcpOperations: object.surfaces.filter((surface) => surface.kind === "mcp").map((surface) => surface.operation).sort(),
+    tableName: object.tableName,
+    idColumnType: object.fields.find((field) => field.name === "id")?.columnType,
+    fields: object.fields.map((field) => ({
+      name: field.name,
+      type: field.type,
+      required: field.required,
+      related: field.related,
+      columnType: field.columnType
+    })),
+    relationships: object.relationships.map((field) => ({
+      name: field.name,
+      type: field.type,
+      required: field.required,
+      related: field.related,
+      columnType: field.columnType
+    })),
+    methods: object.methods
+  }));
+}
+function readDomainKnowledgePrompts(manifest, directory, rootDir) {
+  return manifest.prompts.map((prompt) => ({
+    filePath: relative(rootDir, join(directory, prompt.filePath)),
+    key: prompt.key
+  }));
+}
+function readPrompts(directory, rootDir) {
+  const srcDir = join(directory, "src");
+  if (!existsSync(srcDir)) return [];
+  const prompts = [];
+  for (const filePath of walkFiles(srcDir)) {
+    if (!filePath.endsWith(".ts")) continue;
+    const content = readFileSync(filePath, "utf8");
+    if (!content.includes("definePrompt")) continue;
+    const keyMatch = content.match(/definePrompt\s*\(\s*['"`]([^'"`]+)['"`]/);
+    prompts.push({
+      filePath: relative(rootDir, filePath),
+      key: keyMatch?.[1]
+    });
+  }
+  return prompts;
+}
+function walkFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (WALK_SKIP_DIRS.has(entry.name)) continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkFiles(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function packageKind(name) {
+  if (name.startsWith("@happyvertical/smrt-")) return "smrt";
+  if (SDK_PACKAGE_NAMES.has(name)) return "sdk";
+  return "workspace";
+}
+function exportKeys(exportsField) {
+  if (typeof exportsField === "string") return ["."];
+  if (typeof exportsField !== "object" || exportsField === null || Array.isArray(exportsField)) {
+    return [];
+  }
+  return Object.keys(exportsField).sort();
+}
+function mcpOperations(config) {
+  if (config === false) return [];
+  const defaultOperations = ["list", "get", "create", "update", "delete"];
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    return defaultOperations;
+  }
+  const record = config;
+  const include = Array.isArray(record.include) ? record.include.filter((item) => typeof item === "string") : defaultOperations;
+  const exclude = new Set(
+    Array.isArray(record.exclude) ? record.exclude.filter(
+      (item) => typeof item === "string"
+    ) : []
+  );
+  return include.filter((operation) => !exclude.has(operation));
+}
+function mcpTools(objects) {
+  return objects.flatMap((object) => {
+    const collection = object.collection ?? object.className.toLowerCase();
+    return object.mcpOperations.map((operation) => ({
+      name: `${operation}_${collection}`,
+      sourceObject: object.qualifiedName ?? object.className,
+      operation
+    }));
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function domainMcpTools(manifest) {
+  return manifest.surfaces.filter((surface) => surface.kind === "mcp").map((surface) => ({
+    name: surface.name,
+    sourceObject: surface.objectName ?? "",
+    operation: surface.operation
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function summarizeRelationshipsV2(packages) {
+  const objects = packages.flatMap((pkg) => pkg.objects);
+  const fields = objects.flatMap((object) => object.fields);
+  return {
+    foreignKeyFields: fields.filter((field) => field.type === "foreignKey").length,
+    crossPackageRefFields: fields.filter(
+      (field) => field.type === "crossPackageRef"
+    ).length,
+    junctionCollections: objects.filter(
+      (object) => object.extends === "SmrtJunction"
+    ).length,
+    hierarchicalObjects: objects.filter(
+      (object) => object.extends === "SmrtHierarchical"
+    ).length,
+    polymorphicAssociations: objects.filter(
+      (object) => object.fields.some(
+        (field) => field.name === "metaType" || field.name === "metaId"
+      )
+    ).length,
+    uuidColumns: fields.filter((field) => field.columnType === "UUID").length
+  };
+}
+function relationshipFeatures(objects) {
+  const features = /* @__PURE__ */ new Set();
+  if (objects.some(
+    (object) => object.fields.some((field) => field.type === "foreignKey")
+  )) {
+    features.add("foreignKey");
+  }
+  if (objects.some(
+    (object) => object.fields.some((field) => field.type === "crossPackageRef")
+  )) {
+    features.add("crossPackageRef");
+  }
+  if (objects.some((object) => object.extends === "SmrtJunction")) {
+    features.add("SmrtJunction");
+  }
+  if (objects.some((object) => object.extends === "SmrtHierarchical")) {
+    features.add("SmrtHierarchical");
+  }
+  if (objects.some(
+    (object) => object.fields.some(
+      (field) => field.name === "metaType" || field.name === "metaId"
+    )
+  )) {
+    features.add("SmrtPolymorphicAssociation");
+  }
+  if (objects.some(
+    (object) => object.fields.some((field) => field.columnType === "UUID")
+  )) {
+    features.add("uuidColumns");
+  }
+  return [...features].sort();
+}
+function findStalePatternIssues(rootDir, changedFiles) {
+  const candidates = changedFiles && changedFiles.length > 0 ? changedFiles.map((file) => join(rootDir, file)) : walkFiles(rootDir);
+  const issues = [];
+  for (const file of candidates.filter(
+    (candidate) => shouldScanStalePatternFile(rootDir, candidate)
+  )) {
+    if (!existsSync(file) || lstatSync(file).isDirectory()) continue;
+    const rel = relative(rootDir, file);
+    const content = readFileSync(file, "utf8");
+    for (const stale of STALE_PATTERNS) {
+      if (!stale.pattern.test(content)) continue;
+      issues.push({
+        severity: "warning",
+        code: stale.code,
+        message: stale.message,
+        file: rel
+      });
+    }
+  }
+  return issues;
+}
+function shouldScanStalePatternFile(rootDir, filePath) {
+  const rel = relative(rootDir, filePath).replaceAll("\\", "/");
+  if (!rel || rel.startsWith("..")) return false;
+  const parts = rel.split("/");
+  if (parts.includes("node_modules") || parts.includes("dist")) return false;
+  if (rel === "AGENTS.md" || rel === "README.md") return true;
+  if (rel.endsWith("/AGENTS.md") || rel.endsWith("/README.md")) return true;
+  if (!rel.startsWith("docs/content/") || !rel.endsWith(".md")) return false;
+  return !(rel.startsWith("docs/content/api/") || rel.startsWith("docs/content/rfcs/") || rel.startsWith("docs/content/architecture/"));
+}
+function buildReviewFindings(index, changedFiles, selectedPackages) {
+  const issues = [];
+  for (const pkg of selectedPackages) {
+    const changedPackageFiles = changedFiles.filter(
+      (file) => file === pkg.relativeDirectory || file.startsWith(`${pkg.relativeDirectory}/`)
+    );
+    if (!pkg.agentDoc && pkg.kind === "smrt") {
+      issues.push({
+        severity: "warning",
+        code: "missing-package-expertise",
+        message: "Selected SMRT package has no authored AGENTS.md expertise",
+        file: pkg.relativeDirectory,
+        packageName: pkg.name
+      });
+    }
+    if (changedPackageFiles.some((file) => file.endsWith(".ts")) && pkg.relationshipFeatures.length > 0) {
+      issues.push({
+        severity: "warning",
+        code: "relationship-sensitive-review",
+        message: `Package uses relationships-v2 features: ${pkg.relationshipFeatures.join(", ")}`,
+        file: changedPackageFiles.find((file) => file.endsWith(".ts")),
+        packageName: pkg.name
+      });
+    }
+    if (changedPackageFiles.some((file) => file.endsWith(".ts")) && pkg.mcpTools.length > 0) {
+      issues.push({
+        severity: "warning",
+        code: "mcp-surface-review",
+        message: `Package exposes ${pkg.mcpTools.length} generated MCP tool(s); check public tool compatibility`,
+        file: changedPackageFiles.find((file) => file.endsWith(".ts")),
+        packageName: pkg.name
+      });
+    }
+    const manifestFile = changedPackageFiles.find(
+      (file) => isPackageManifestFile(pkg, file)
+    );
+    if (manifestFile) {
+      issues.push({
+        severity: "warning",
+        code: "package-manifest-review",
+        message: "package.json changed; verify exports, files, dependencies, AGENTS.md, and CLAUDE.md shim packaging",
+        file: manifestFile,
+        packageName: pkg.name
+      });
+    }
+    const publicEntrypointFile = changedPackageFiles.find(
+      (file) => isPublicEntrypointFile(pkg, file)
+    );
+    if (publicEntrypointFile) {
+      issues.push({
+        severity: "warning",
+        code: "public-entrypoint-review",
+        message: "Public package entrypoint changed; check exports, generated surfaces, and downstream docs",
+        file: publicEntrypointFile,
+        packageName: pkg.name
+      });
+    }
+    const agentDocFile = changedPackageFiles.find(
+      (file) => isPackageAgentDocFile(pkg, file)
+    );
+    if (agentDocFile) {
+      issues.push({
+        severity: "warning",
+        code: "agent-expertise-review",
+        message: "AGENTS.md changed; validate authored expertise against generated objects, relationships, exports, and SDK dependencies",
+        file: agentDocFile,
+        packageName: pkg.name
+      });
+    }
+  }
+  for (const file of changedFiles) {
+    if (!file.startsWith("packages/")) continue;
+    if (selectPackagesForFiles(index, [file]).length > 0) continue;
+    issues.push({
+      severity: "warning",
+      code: "changed-file-without-package-expert",
+      message: "Changed file is under packages/ but did not map to a SMRT package",
+      file
+    });
+  }
+  return issues;
+}
+function isPackageManifestFile(pkg, file) {
+  return file === `${pkg.relativeDirectory}/package.json`;
+}
+function isPackageAgentDocFile(pkg, file) {
+  return file === `${pkg.relativeDirectory}/AGENTS.md`;
+}
+function isPublicEntrypointFile(pkg, file) {
+  const sourcePrefix = `${pkg.relativeDirectory}/src/`;
+  if (!file.startsWith(sourcePrefix)) return false;
+  const sourcePath = file.slice(sourcePrefix.length);
+  return sourcePath === "index.ts" || sourcePath === "index.tsx" || sourcePath === "index.js" || sourcePath.startsWith("api/") || sourcePath.startsWith("cli/") || sourcePath.startsWith("mcp/") || sourcePath.startsWith("tools/");
+}
+function buildArchitectureRecommendations(context, ideaText) {
+  const smrtPackages = context.selectedPackages.map((pkg) => pkg.name);
+  const sdkPackages = context.selectedSdkPackages.map((pkg) => pkg.name);
+  const objectModelSketch = buildObjectModelSketch(context.selectedPackages);
+  const risks = buildArchitectureRisks(context.selectedPackages, ideaText);
+  const questions = buildArchitectureQuestions(
+    context.selectedPackages,
+    ideaText
+  );
+  return {
+    smrtPackages,
+    sdkPackages,
+    objectModelSketch,
+    risks,
+    questions,
+    notes: [
+      "Use SMRT packages for domain/runtime models and generated REST, CLI, MCP, and AI-operation surfaces.",
+      "Use HappyVertical SDK packages for AI, SQL, files, logging, secrets, and external capability adapters.",
+      "Run smrt dev:knowledge-check after applying model-assisted architecture or review updates."
+    ]
+  };
+}
+function buildObjectModelSketch(packages) {
+  const lines = packages.flatMap((pkg) => {
+    const objects = pkg.objects.filter((object) => object.extends !== "SmrtCollection").slice(0, 6).map((object) => object.className);
+    if (objects.length === 0) {
+      return [
+        `${pkg.name}: use package services or templates; no manifest objects indexed.`
+      ];
+    }
+    return [`${pkg.name}: start from ${objects.join(", ")}.`];
+  });
+  return lines.length > 0 ? lines : [
+    "Define the core domain as SmrtObject classes with explicit relationships and generated surfaces."
+  ];
+}
+function buildArchitectureRisks(packages, ideaText) {
+  const risks = /* @__PURE__ */ new Set();
+  const names = new Set(packages.map((pkg) => pkg.name));
+  const relationshipFeatures2 = new Set(
+    packages.flatMap((pkg) => pkg.relationshipFeatures)
+  );
+  const lowerText = ideaText.toLowerCase();
+  if (relationshipFeatures2.has("crossPackageRef")) {
+    risks.add(
+      "Cross-package references should stay as plain string ids and validate target package ownership at workflow boundaries."
+    );
+  }
+  if (relationshipFeatures2.has("SmrtJunction")) {
+    risks.add(
+      "Junction models need explicit conflictColumns so generated upserts stay deterministic."
+    );
+  }
+  if (relationshipFeatures2.has("SmrtHierarchical")) {
+    risks.add(
+      "Hierarchical models need cycle prevention and tenant-aware child loading paths."
+    );
+  }
+  if (names.has("@happyvertical/smrt-tenancy") || lowerText.includes("tenant")) {
+    risks.add(
+      "Tenant-scoped models need nullable tenantId semantics and tenant-guarded loadRelated usage."
+    );
+  }
+  if (names.has("@happyvertical/smrt-assets")) {
+    risks.add(
+      "Asset ownership should use package-owned join tables; reserve asset_associations for generic/provenance links."
+    );
+  }
+  if (names.has("@happyvertical/smrt-secrets")) {
+    risks.add(
+      "Secrets must use envelope encryption and avoid exposing decrypted values through generated tools."
+    );
+  }
+  if (names.has("@happyvertical/smrt-jobs") || lowerText.includes("schedule")) {
+    risks.add(
+      "Background work should use jobs/schedules rather than request-time side effects."
+    );
+  }
+  risks.add(
+    "Generated architecture should be rechecked with smrt dev:knowledge-check after docs or expertise edits."
+  );
+  return [...risks];
+}
+function buildArchitectureQuestions(packages, ideaText) {
+  const questions = /* @__PURE__ */ new Set();
+  const names = new Set(packages.map((pkg) => pkg.name));
+  const lowerText = ideaText.toLowerCase();
+  questions.add(
+    "Which generated surfaces are required first: REST, CLI, MCP, AI operations, or Svelte UI?"
+  );
+  if (names.has("@happyvertical/smrt-tenancy") || lowerText.includes("tenant")) {
+    questions.add(
+      "Which objects are global catalogs and which are tenant-scoped records?"
+    );
+  }
+  if (names.has("@happyvertical/smrt-assets")) {
+    questions.add("Which package owns each asset relationship join table?");
+  }
+  if (names.has("@happyvertical/smrt-profiles")) {
+    questions.add("Which identities own or administer the primary records?");
+  }
+  if (names.has("@happyvertical/smrt-content")) {
+    questions.add(
+      "Which content snapshots need citation-time reference pinning?"
+    );
+  }
+  if (names.has("@happyvertical/smrt-social")) {
+    questions.add(
+      "Which social providers need OAuth, scheduling, and post-state reconciliation?"
+    );
+  }
+  return [...questions];
+}
+function selectPackagesForFiles(index, changedFiles) {
+  const selected = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    for (const pkg of domainPackages(index)) {
+      if (file === pkg.relativeDirectory || file.startsWith(`${pkg.relativeDirectory}/`)) {
+        selected.add(pkg);
+      }
+    }
+  }
+  return [...selected].sort((a, b) => a.name.localeCompare(b.name));
+}
+function selectPackages(index, options) {
+  const selected = /* @__PURE__ */ new Set();
+  const packageName = options.packageName?.toLowerCase();
+  if (packageName) {
+    for (const pkg of domainPackages(index)) {
+      if (packageMatches(pkg, packageName)) {
+        selected.add(pkg);
+      }
+    }
+  }
+  for (const pkg of selectPackagesForFiles(index, options.changedFiles ?? [])) {
+    if (scopeAllowsPackage(pkg, options.scope)) selected.add(pkg);
+  }
+  const text = (options.text ?? "").toLowerCase();
+  if (text) {
+    for (const pkg of domainPackages(index)) {
+      if (!scopeAllowsPackage(pkg, options.scope)) continue;
+      const packageKey = pkg.name.replace("@happyvertical/smrt-", "");
+      if (includesToken(text, packageKey) || text.includes(pkg.name.toLowerCase()) || pkg.objects.some(
+        (object) => includesToken(text, object.className.toLowerCase())
+      )) {
+        selected.add(pkg);
+      }
+    }
+  }
+  if (selected.size === 0 && options.scope === "local") {
+    for (const pkg of domainPackages(index).filter(
+      (item) => scopeAllowsPackage(item, "local")
+    )) {
+      selected.add(pkg);
+    }
+  }
+  if (selected.size === 0 && options.scope !== "sdk") {
+    for (const name of [
+      "@happyvertical/smrt-core",
+      "@happyvertical/smrt-config",
+      "@happyvertical/smrt-cli",
+      "@happyvertical/smrt-scanner",
+      "@happyvertical/smrt-dev-mcp"
+    ]) {
+      const pkg = index.smrtPackages.find((item) => item.name === name);
+      if (pkg) selected.add(pkg);
+    }
+  }
+  return [...selected].sort((a, b) => a.name.localeCompare(b.name));
+}
+function selectSdkPackages(index, selectedPackages, texts, options = {}) {
+  const selected = /* @__PURE__ */ new Set();
+  const sdkNames = new Set(
+    selectedPackages.flatMap((pkg) => pkg.sdkDependencies)
+  );
+  const text = texts.filter(Boolean).join("\n").toLowerCase();
+  const packageName = options.packageName?.toLowerCase();
+  for (const sdk of index.sdkPackages) {
+    const shortName = sdk.name.replace("@happyvertical/", "");
+    if (options.scope === "sdk" || sdkNames.has(sdk.name) || packageName && packageMatches(sdk, packageName) || text.includes(sdk.name.toLowerCase()) || includesToken(text, shortName)) {
+      selected.add(sdk);
+    }
+  }
+  if (selected.size === 0) {
+    for (const name of [
+      "@happyvertical/ai",
+      "@happyvertical/sql",
+      "@happyvertical/files",
+      "@happyvertical/utils"
+    ]) {
+      const sdk = index.sdkPackages.find((item) => item.name === name);
+      if (sdk) selected.add(sdk);
+    }
+  }
+  return [...selected].sort((a, b) => a.name.localeCompare(b.name));
+}
+function domainPackages(index) {
+  return index.packages.filter((pkg) => pkg.kind !== "sdk");
+}
+function scopeAllowsPackage(pkg, scope) {
+  switch (scope) {
+    case "sdk":
+      return false;
+    case "local":
+      return !pkg.relativeDirectory.includes("node_modules");
+    case "package":
+    case "project":
+    case void 0:
+      return true;
+  }
+}
+function packageMatches(pkg, query) {
+  const normalized = query.toLowerCase();
+  const shortName = pkg.name.replace("@happyvertical/smrt-", "").replace("@happyvertical/", "");
+  return pkg.name.toLowerCase() === normalized || pkg.name.toLowerCase().includes(normalized) || shortName.toLowerCase() === normalized || pkg.relativeDirectory.toLowerCase().endsWith(`/${normalized}`);
+}
+function buildPromptBundle(options) {
+  const contextMarkdown = [
+    `# ${options.title}`,
+    "",
+    `Baseline root: ${options.index.rootDir}`,
+    "",
+    "## Task",
+    "",
+    options.task,
+    "",
+    "## Relationships-v2 Summary",
+    "",
+    JSON.stringify(options.index.relationshipsV2, null, 2),
+    "",
+    "## Selected SMRT Packages",
+    "",
+    ...options.packages.map(renderPackageContext),
+    "",
+    "## Selected SDK Packages",
+    "",
+    ...options.sdkPackages.map(renderPackageContext),
+    "",
+    options.extraContext ? `## Extra Context
+
+${options.extraContext}
+` : ""
+  ];
+  return {
+    title: options.title,
+    instructions: "Use the supplied SMRT knowledge context as source material. Return concrete findings or architecture guidance with package names and source references. Do not assume model-provider access.",
+    contextMarkdown: contextMarkdown.join("\n"),
+    selectedPackages: options.packages.map((pkg) => pkg.name),
+    selectedSdkPackages: options.sdkPackages.map((pkg) => pkg.name),
+    sourceFiles: options.sourceFiles
+  };
+}
+function renderPackageContext(pkg) {
+  const lines = [
+    `### ${pkg.name}`,
+    "",
+    `- version: ${pkg.version}`,
+    `- kind: ${pkg.kind}`,
+    `- directory: ${pkg.relativeDirectory}`,
+    `- domain knowledge: ${pkg.domainKnowledgePath ?? "(manifest fallback)"}`,
+    `- docs: ${pkg.docSource ?? "(none)"}`,
+    `- relationship features: ${pkg.relationshipFeatures.join(", ") || "(none)"}`,
+    `- SDK deps: ${pkg.sdkDependencies.join(", ") || "(none)"}`,
+    `- exports: ${pkg.exportKeys.join(", ") || "(none)"}`,
+    `- MCP tools: ${pkg.mcpTools.slice(0, 20).map((tool) => tool.name).join(", ") || "(none)"}`,
+    `- objects: ${pkg.objects.slice(0, 20).map((object) => object.qualifiedName ?? object.className).join(", ")}`
+  ];
+  if (pkg.objects.length > 20) {
+    lines.push(`- object count: ${pkg.objects.length}`);
+  }
+  if (pkg.agentDoc) {
+    lines.push("", pkg.agentDoc.trim());
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function getChangedFiles(rootDir, base) {
+  if (base) {
+    try {
+      const output = execFileSync(
+        "git",
+        ["diff", "--name-only", `${base}...HEAD`],
+        {
+          cwd: rootDir,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }
+      );
+      const files = output.split("\n").map((line) => line.trim()).filter(Boolean);
+      if (files.length > 0) return files;
+    } catch {
+    }
+  }
+  try {
+    const output = execFileSync("git", ["diff", "--name-only"], {
+      cwd: rootDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const cachedOutput = execFileSync(
+      "git",
+      ["diff", "--cached", "--name-only"],
+      {
+        cwd: rootDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    );
+    return uniqueStrings(
+      [output, cachedOutput].flatMap(
+        (value) => value.split("\n").map((line) => line.trim()).filter(Boolean)
+      )
+    );
+  } catch {
+    return [];
+  }
+}
+function dedupePackages(packages) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const current = byName.get(pkg.name);
+    if (!current || current.kind === "sdk") {
+      byName.set(pkg.name, pkg);
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function includesToken(text, token) {
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${escaped}\\b`, "i").test(text);
+}
+function readJson(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function hashFile(path) {
+  return createHash("sha256").update(readFileSync(path, "utf8")).digest("hex");
+}
+function hashJsonFile(path) {
+  const content = readJson(path);
+  const hashContent = content ? stableJson(normalizeJsonForHash(content)) : readFileSync(path, "utf8");
+  return createHash("sha256").update(hashContent).digest("hex");
+}
+function objectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function camelToSnake(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+function uniqueStrings(values) {
+  return [...new Set(values)].sort();
+}
+function normalizeJsonForHash(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const normalized = { ...value };
+  delete normalized.timestamp;
+  return normalized;
+}
+function stableJson(value) {
+  return JSON.stringify(sortJson(value), null, 2);
+}
+function sortJson(value) {
+  if (Array.isArray(value)) return value.map(sortJson);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, sortJson(entry)])
+    );
+  }
+  return value;
+}
+
+export { buildKnowledgeIndex as a, buildArchitectureContext as b, buildReviewContext as c, checkKnowledgeFreshness as d, checkKnowledgeFreshnessFromIndex as e, diffKnowledgeIndex as f, renderKnowledgeIndexMarkdown as g, smrtReview as h, renderFreshnessResult as r, smrtArchitecture as s };
+//# sourceMappingURL=index-DF0HSB_8.js.map