@happyvertical/smrt-dev-mcp 0.30.0

package/dist/index.js

@@ -0,0 +1,2039 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync, realpathSync } from 'node:fs';
+import { join, dirname, resolve, relative, isAbsolute, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, McpError, ErrorCode, ListResourcesRequestSchema, ReadResourceRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { c as buildReviewContext, b as buildArchitectureContext, a as buildKnowledgeIndex, s as smrtArchitecture, h as smrtReview, d as checkKnowledgeFreshness, e as checkKnowledgeFreshnessFromIndex } from './index-DF0HSB_8.js';
+import { access, readFile, readdir } from 'node:fs/promises';
+import { ManifestGenerator } from '@happyvertical/smrt-core/scanner';
+import { OxcScanner, ManifestAdapter } from '@happyvertical/smrt-scanner';
+
+const AGENT_SKILLS = [
+  {
+    name: "smrt-code-review",
+    description: "Harness-agnostic downstream SMRT code review workflow using smrt-dev-mcp deterministic context and prompt bundles.",
+    path: "agent-skills/smrt-code-review/SKILL.md",
+    skillFile: "agent-skills/smrt-code-review/SKILL.md",
+    references: ["agent-skills/smrt-code-review/references/review-output.md"]
+  }
+];
+function listAgentSkills() {
+  return AGENT_SKILLS.map(({ skillFile: _skillFile, ...skill }) => skill);
+}
+function getAgentSkill(options) {
+  const skill = AGENT_SKILLS.find((item) => item.name === options.name);
+  if (!skill) {
+    throw new Error(`Unknown agent skill: ${options.name}`);
+  }
+  return {
+    name: skill.name,
+    description: skill.description,
+    path: skill.path,
+    references: skill.references,
+    skillMarkdown: readPackageFile(skill.skillFile),
+    referenceFiles: options.includeReferences === false ? [] : skill.references.map((path) => ({
+      path,
+      content: readPackageFile(path)
+    }))
+  };
+}
+function readPackageFile(relativePath) {
+  const packageRoot = resolvePackageRoot();
+  return readFileSync(join(packageRoot, relativePath), "utf8");
+}
+function resolvePackageRoot() {
+  const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+  if (!existsSync(join(packageRoot, "package.json"))) {
+    throw new Error(
+      `Unable to resolve smrt-dev-mcp package root from ${import.meta.url}`
+    );
+  }
+  return packageRoot;
+}
+
+const TYPE_MAPPING = {
+  text: { tsType: "string", defaultValue: "''" },
+  integer: { tsType: "number", defaultValue: "0" },
+  decimal: { tsType: "number", defaultValue: "0.0" },
+  boolean: { tsType: "boolean", defaultValue: "false" },
+  datetime: { tsType: "Date", defaultValue: "new Date()" },
+  json: { tsType: "any", defaultValue: "{}" }
+};
+async function generateSmrtClass(args) {
+  const normalized = normalizeArgs(args);
+  const {
+    className,
+    properties,
+    relationships,
+    baseClass,
+    tableName,
+    conflictColumns,
+    tenantScoped,
+    includeTenantIdField,
+    includeApiConfig,
+    includeMcpConfig,
+    includeCliConfig,
+    includeCompanionSnippets
+  } = normalized;
+  const coreImports = /* @__PURE__ */ new Set([baseClass, "smrt"]);
+  if (needsFieldDecorator(properties)) coreImports.add("field");
+  for (const relationship of relationships) {
+    coreImports.add(relationship.type);
+  }
+  const imports = [
+    `import { ${Array.from(coreImports).join(", ")} } from '@happyvertical/smrt-core';`
+  ];
+  if (tenantScoped) {
+    const tenancyImports = ["TenantScoped"];
+    if (includeTenantIdField) tenancyImports.push("tenantId");
+    imports.push(
+      `import { ${tenancyImports.join(", ")} } from '@happyvertical/smrt-tenancy';`
+    );
+  }
+  const decoratorLines = [
+    ...tenantScoped ? [`@TenantScoped(${renderObjectLiteral({ ...tenantScoped })})`] : [],
+    renderSmrtDecorator({
+      includeApiConfig,
+      includeMcpConfig,
+      includeCliConfig,
+      tableName,
+      conflictColumns
+    })
+  ];
+  const classMembers = [
+    ...includeTenantIdField && tenantScoped ? [renderTenantIdField(tenantScoped)] : [],
+    ...properties.map(renderProperty),
+    ...relationships.map(renderRelationship)
+  ].filter(Boolean);
+  const companionSnippets = includeCompanionSnippets ? `
+${renderCompanionSnippets(className, Boolean(tenantScoped))}` : "";
+  return `${imports.join("\n")}
+
+${decoratorLines.join("\n")}
+export class ${className} extends ${baseClass} {
+${classMembers.join("\n\n")}
+
+  constructor(options: any = {}) {
+    super(options);
+    Object.assign(this, options);
+  }
+}
+${companionSnippets}`;
+}
+function normalizeArgs(args) {
+  const template = args.template ?? "basic";
+  const templateDefaults = defaultsForTemplate(template);
+  const tenantScoped = args.tenantScoped === true ? templateDefaults.tenantScoped ?? { mode: "required" } : args.tenantScoped === false ? void 0 : args.tenantScoped ?? templateDefaults.tenantScoped;
+  return {
+    className: args.className,
+    properties: args.properties,
+    baseClass: args.baseClass ?? "SmrtObject",
+    template,
+    tableName: args.tableName ?? templateDefaults.tableName,
+    conflictColumns: args.conflictColumns ?? templateDefaults.conflictColumns ?? [],
+    tenantScoped: normalizeTenantScoped(tenantScoped),
+    includeTenantIdField: args.includeTenantIdField ?? templateDefaults.includeTenantIdField ?? Boolean(tenantScoped),
+    relationships: args.relationships ?? [],
+    includeApiConfig: args.includeApiConfig ?? true,
+    includeMcpConfig: args.includeMcpConfig ?? true,
+    includeCliConfig: args.includeCliConfig ?? true,
+    includeCompanionSnippets: args.includeCompanionSnippets ?? false
+  };
+}
+function defaultsForTemplate(template) {
+  switch (template) {
+    case "optional-catalog":
+      return {
+        tenantScoped: { mode: "optional" },
+        includeTenantIdField: true,
+        conflictColumns: ["tenant_id", "slug"]
+      };
+    case "tenant-project-object":
+      return {
+        tenantScoped: { mode: "required" },
+        includeTenantIdField: true
+      };
+    case "tenant-event-log-object":
+      return {
+        tenantScoped: { mode: "optional" },
+        includeTenantIdField: true
+      };
+    case "global-catalog":
+      return { conflictColumns: ["slug"] };
+    case "cross-package-reference":
+    case "basic":
+      return {};
+  }
+}
+function normalizeTenantScoped(value) {
+  if (!value) return void 0;
+  return {
+    mode: typeof value === "object" ? value.mode ?? "required" : "required",
+    field: typeof value === "object" ? value.field ?? "tenantId" : "tenantId",
+    autoFilter: typeof value === "object" ? value.autoFilter : void 0,
+    autoPopulate: typeof value === "object" ? value.autoPopulate : void 0,
+    allowSuperAdminBypass: typeof value === "object" ? value.allowSuperAdminBypass : void 0
+  };
+}
+function renderSmrtDecorator(options) {
+  const decoratorConfig = {};
+  if (options.tableName) {
+    decoratorConfig.tableName = options.tableName;
+  }
+  if (options.conflictColumns.length > 0) {
+    decoratorConfig.conflictColumns = options.conflictColumns;
+  }
+  if (options.includeApiConfig) {
+    decoratorConfig.api = {
+      include: ["list", "get", "create", "update"],
+      exclude: ["delete"]
+    };
+  }
+  if (options.includeMcpConfig) {
+    decoratorConfig.mcp = {
+      include: ["list", "get"]
+    };
+  }
+  if (options.includeCliConfig) {
+    decoratorConfig.cli = true;
+  }
+  return Object.keys(decoratorConfig).length > 0 ? `@smrt(${JSON.stringify(decoratorConfig, null, 2)})` : "@smrt()";
+}
+function renderTenantIdField(tenantScoped) {
+  const nullable = tenantScoped.mode === "optional";
+  const field = tenantScoped.field ?? "tenantId";
+  return nullable ? `  @tenantId({ nullable: true })
+  ${field}: string | null = null;` : `  @tenantId()
+  ${field}: string = '';`;
+}
+function renderProperty(prop) {
+  const mapping = TYPE_MAPPING[prop.type];
+  const nullable = prop.nullable === true;
+  const tsType = nullable ? `${mapping.tsType} | null` : mapping.tsType;
+  const defaultValue = prop.defaultValue !== void 0 ? renderLiteral(prop.defaultValue) : nullable ? "null" : mapping.defaultValue;
+  const fieldOptions = compactObject$1({
+    required: prop.required,
+    nullable: prop.nullable,
+    description: prop.description
+  });
+  const jsdoc = prop.description ? `  /** ${prop.description} */
+` : "";
+  const decorator = Object.keys(fieldOptions).length > 0 ? `  @field(${JSON.stringify(fieldOptions)})
+` : "";
+  return `${jsdoc}${decorator}  ${prop.name}: ${tsType} = ${defaultValue};`;
+}
+function renderRelationship(relationship) {
+  const options = compactObject$1({
+    required: relationship.required,
+    nullable: relationship.nullable,
+    description: relationship.description,
+    validate: relationship.validate,
+    foreignKey: relationship.foreignKey,
+    through: relationship.through,
+    sourceKey: relationship.sourceKey,
+    targetKey: relationship.targetKey
+  });
+  const args = [
+    renderLiteral(relationship.related),
+    ...Object.keys(options).length > 0 ? [JSON.stringify(options)] : []
+  ];
+  const decorator = `@${relationship.type}(${args.join(", ")})`;
+  const fieldType = relationship.type === "oneToMany" || relationship.type === "manyToMany" ? "unknown[]" : relationship.nullable ? "string | null" : "string";
+  const defaultValue = relationship.type === "oneToMany" || relationship.type === "manyToMany" ? "[]" : relationship.nullable ? "null" : "''";
+  return `  ${decorator}
+  ${relationship.name}: ${fieldType} = ${defaultValue};`;
+}
+function needsFieldDecorator(properties) {
+  return properties.some(
+    (property) => property.required !== void 0 || property.nullable !== void 0 || property.description !== void 0
+  );
+}
+function renderCompanionSnippets(className, usesTenantScoped) {
+  const dependencyNote = usesTenantScoped ? `
+ * - Ensure package.json declares "@happyvertical/smrt-tenancy".` : "";
+  return `/*
+ * Package wiring:
+ * - Export ${className} from the package entrypoint used by consumers.
+ * - Import this module from any package registration file that eagerly loads objects.${dependencyNote}
+ */`;
+}
+function renderObjectLiteral(value) {
+  return JSON.stringify(compactObject$1(value), null, 2);
+}
+function renderLiteral(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null) return "null";
+  return JSON.stringify(value, null, 2);
+}
+function compactObject$1(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+
+const DEFAULT_MANIFEST_PATHS = [
+  ".smrt/manifest.json",
+  "dist/manifest.json",
+  "src/manifest/manifest.json"
+];
+const SCAN_EXCLUDE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.git/**",
+  "**/.smrt/**",
+  "**/*.d.ts",
+  "**/*.test.ts",
+  "**/*.spec.ts",
+  "**/__tests__/**"
+];
+const RELATIONSHIP_TYPES = /* @__PURE__ */ new Set([
+  "foreignKey",
+  "crossPackageRef",
+  "oneToMany",
+  "manyToMany"
+]);
+async function introspectProject(args) {
+  const {
+    directory = process.cwd(),
+    includeFields = true,
+    includeRelationships = true,
+    includeMethods = true
+  } = args;
+  const projectPath = resolve(directory);
+  const exists = await pathExists$1(projectPath);
+  if (!exists) {
+    return JSON.stringify(
+      {
+        projectPath,
+        manifestSource: "none",
+        objectCount: 0,
+        objects: [],
+        diagnostics: [
+          {
+            severity: "warning",
+            message: `Project directory does not exist: ${projectPath}`
+          }
+        ]
+      },
+      null,
+      2
+    );
+  }
+  const packageMetadata = await readPackageMetadata(projectPath);
+  const tenantScopes = await scanTenantScopes(projectPath);
+  const manifestResult = await loadManifestArtifact(projectPath, args.manifestPath) ?? await scanSourceManifest(projectPath, packageMetadata);
+  const objects = Object.entries(manifestResult.manifest.objects ?? {}).map(
+    ([manifestKey, object]) => formatObject({
+      manifestKey,
+      object,
+      projectPath,
+      includeFields,
+      includeRelationships,
+      includeMethods,
+      tenantScope: tenantScopes.get(object.className)
+    })
+  ).sort((left, right) => left.className.localeCompare(right.className));
+  const output = {
+    projectPath,
+    manifestSource: manifestResult.source,
+    manifestPath: "path" in manifestResult ? relative(projectPath, manifestResult.path) : void 0,
+    packageName: manifestResult.manifest.packageName ?? packageMetadata.name ?? void 0,
+    packageVersion: manifestResult.manifest.packageVersion ?? packageMetadata.version ?? void 0,
+    objectCount: objects.length,
+    scannedFileCount: manifestResult.scannedFileCount,
+    parseTimeMs: manifestResult.parseTimeMs,
+    objects,
+    diagnostics: manifestResult.diagnostics
+  };
+  return JSON.stringify(output, null, 2);
+}
+async function loadManifestArtifact(projectPath, manifestPath) {
+  const candidates = manifestPath ? [resolve(projectPath, manifestPath)] : DEFAULT_MANIFEST_PATHS.map((candidate) => join(projectPath, candidate));
+  const diagnostics = [];
+  for (const candidate of candidates) {
+    if (!await pathExists$1(candidate)) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(await readFile(candidate, "utf-8"));
+      if (isManifestLike(parsed)) {
+        return {
+          source: "manifest",
+          path: candidate,
+          manifest: parsed,
+          diagnostics
+        };
+      }
+      diagnostics.push({
+        severity: "warning",
+        filePath: candidate,
+        message: "Manifest artifact is present but does not contain objects."
+      });
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        filePath: candidate,
+        message: `Unable to parse manifest artifact: ${messageFromError(error)}`
+      });
+    }
+  }
+  return manifestPath ? {
+    source: "manifest",
+    path: resolve(projectPath, manifestPath),
+    manifest: { objects: {} },
+    diagnostics: [
+      ...diagnostics,
+      {
+        severity: "warning",
+        filePath: resolve(projectPath, manifestPath),
+        message: "Requested manifest artifact was not found."
+      }
+    ]
+  } : void 0;
+}
+async function scanSourceManifest(projectPath, packageMetadata) {
+  const scanner = new OxcScanner({
+    cwd: projectPath,
+    include: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
+    exclude: SCAN_EXCLUDE
+  });
+  const { results, resolved } = await scanner.scanAndResolve();
+  const adapter = new ManifestAdapter();
+  const manifest = adapter.toManifest(
+    resolved.filter((classDef) => classDef.hasSmartDecorator),
+    {
+      packageName: packageMetadata.name,
+      packageVersion: packageMetadata.version,
+      typeAliases: results.typeAliases
+    }
+  );
+  finalizeScannerManifest(manifest, packageMetadata);
+  return {
+    source: "scanner",
+    manifest,
+    diagnostics: results.errors.map(scanErrorToDiagnostic),
+    scannedFileCount: results.fileCount,
+    parseTimeMs: Math.round(results.totalParseTimeMs)
+  };
+}
+function finalizeScannerManifest(manifest, packageMetadata) {
+  const manifestGen = new ManifestGenerator();
+  const fullManifest = manifest;
+  withSuppressedConsoleLog(() => {
+    manifestGen.injectTenantScopedFields(fullManifest);
+    manifestGen.mergeInheritedFields(fullManifest);
+    manifestGen.generateValidationRules(fullManifest);
+    manifestGen.generateSchemas(fullManifest);
+    manifestGen.assertTenantScopedSchemaContract(fullManifest);
+    manifestGen.generateAgentManifests(
+      fullManifest,
+      packageMetadata.name,
+      packageMetadata.json
+    );
+  });
+}
+function withSuppressedConsoleLog(callback) {
+  const originalLog = console.log;
+  console.log = () => void 0;
+  try {
+    return callback();
+  } finally {
+    console.log = originalLog;
+  }
+}
+function formatObject({
+  manifestKey,
+  object,
+  projectPath,
+  includeFields,
+  includeRelationships,
+  includeMethods,
+  tenantScope
+}) {
+  const fieldDetails = Object.entries(object.fields ?? {}).map(
+    ([name, field]) => ({
+      name,
+      type: field.type,
+      ...field.required !== void 0 ? { required: field.required } : {},
+      ...field.default !== void 0 ? { default: field.default } : {},
+      ...field.related ? { related: field.related } : {},
+      ...field.description ? { description: field.description } : {},
+      ...field._meta ? { meta: field._meta } : {},
+      ...field.transient !== void 0 ? { transient: field.transient } : {}
+    })
+  );
+  const relationshipDetails = fieldDetails.filter((field) => RELATIONSHIP_TYPES.has(field.type)).map((field) => ({
+    field: field.name,
+    relatedClass: field.related ?? "",
+    type: field.type,
+    ...field.meta ? { meta: field.meta } : {}
+  }));
+  const methodDetails = Object.entries(object.methods ?? {}).map(
+    ([name, method]) => ({
+      name: method.name ?? name,
+      isAsync: method.async === true,
+      isStatic: method.isStatic === true,
+      isPublic: method.isPublic !== false,
+      parameters: method.parameters ?? [],
+      returnType: method.returnType ?? "unknown",
+      ...method.description ? { description: method.description } : {}
+    })
+  );
+  const decoratorConfig = object.decoratorConfig ?? {};
+  const effectiveTenantScope = tenantScope ?? normalizeTenantScopedConfig(decoratorConfig.tenantScoped);
+  const schema = object.schema;
+  return compactObject({
+    manifestKey,
+    name: object.name,
+    className: object.className,
+    qualifiedName: object.qualifiedName,
+    filePath: sanitizePath$1(projectPath, object.filePath),
+    packageName: object.packageName,
+    packageVersion: object.packageVersion,
+    importPath: object.importPath,
+    modulePath: object.modulePath,
+    exportName: object.exportName,
+    collectionExportName: object.collectionExportName,
+    collection: object.collection,
+    extends: object.extends,
+    extendsTypeArg: object.extendsTypeArg,
+    tableName: schema?.tableName ?? stringFromConfig(decoratorConfig.tableName) ?? object.collection,
+    tableStrategy: stringFromConfig(decoratorConfig.tableStrategy) ?? "cti",
+    conflictColumns: arrayFromConfig(decoratorConfig.conflictColumns),
+    tenantScope: effectiveTenantScope,
+    decoratorConfig,
+    schema: schema ? {
+      tableName: schema.tableName,
+      columns: schema.columns,
+      indexes: schema.indexes ?? [],
+      version: schema.version
+    } : void 0,
+    indexes: schema?.indexes ?? [],
+    staticProperties: object.staticProperties,
+    validationRules: object.validationRules,
+    ...includeFields && {
+      fields: fieldDetails.map((field) => `${field.name}: ${field.type}`).join(", "),
+      fieldDetails
+    },
+    ...includeRelationships && relationshipDetails.length > 0 && {
+      relationships: relationshipDetails.map(
+        (relationship) => `${relationship.field} -> ${relationship.relatedClass} (${relationship.type})`
+      ).join(", "),
+      relationshipDetails
+    },
+    ...includeMethods && methodDetails.length > 0 && {
+      methods: methodDetails.map((method) => `${method.isAsync ? "async " : ""}${method.name}()`).join(", "),
+      methodDetails
+    }
+  });
+}
+async function scanTenantScopes(projectPath) {
+  const files = await listSourceFiles$1(projectPath);
+  const scopes = /* @__PURE__ */ new Map();
+  await Promise.all(
+    files.map(async (filePath) => {
+      const content = await readFile(filePath, "utf-8");
+      const classMatches = content.matchAll(/class\s+([A-Za-z_]\w*)\b/g);
+      for (const match of classMatches) {
+        const className = match[1];
+        if (!className || match.index === void 0) continue;
+        const prefix = content.slice(
+          Math.max(0, match.index - 800),
+          match.index
+        );
+        const tenantMatches = Array.from(
+          prefix.matchAll(/@TenantScoped\s*\(([\s\S]*?)\)/g)
+        );
+        const tenantMatch = tenantMatches.at(-1);
+        if (!tenantMatch) continue;
+        scopes.set(className, {
+          source: "TenantScoped",
+          ...parseTenantScopedOptions(tenantMatch[1])
+        });
+      }
+    })
+  );
+  return scopes;
+}
+async function listSourceFiles$1(projectPath) {
+  const files = [];
+  async function visit(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if ([
+          "node_modules",
+          "dist",
+          "build",
+          ".git",
+          ".smrt",
+          "__tests__"
+        ].includes(entry.name) || entry.name.startsWith(".")) {
+          continue;
+        }
+        await visit(fullPath);
+        continue;
+      }
+      if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".spec.ts")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  await visit(projectPath);
+  return files;
+}
+function parseTenantScopedOptions(raw) {
+  const mode = raw.match(/mode\s*:\s*['"`](required|optional)['"`]/)?.[1];
+  const field = raw.match(/field\s*:\s*['"`]([A-Za-z_]\w*)['"`]/)?.[1];
+  const allowSuperAdminBypass = raw.match(
+    /allowSuperAdminBypass\s*:\s*(true|false)/
+  )?.[1];
+  const autoFilter = raw.match(/autoFilter\s*:\s*(true|false)/)?.[1];
+  const autoPopulate = raw.match(/autoPopulate\s*:\s*(true|false)/)?.[1];
+  return compactObject({
+    mode: mode ?? "required",
+    field: field ?? "tenantId",
+    autoFilter: autoFilter === void 0 ? void 0 : autoFilter === "true",
+    autoPopulate: autoPopulate === void 0 ? void 0 : autoPopulate === "true",
+    allowSuperAdminBypass: allowSuperAdminBypass === void 0 ? void 0 : allowSuperAdminBypass === "true"
+  });
+}
+function normalizeTenantScopedConfig(tenantScoped) {
+  if (!tenantScoped) return void 0;
+  const options = typeof tenantScoped === "object" && !Array.isArray(tenantScoped) ? tenantScoped : {};
+  return {
+    source: "smrt",
+    mode: options.mode ?? "required",
+    field: options.field ?? "tenantId",
+    autoFilter: options.autoFilter ?? true,
+    autoPopulate: options.autoPopulate ?? true,
+    allowSuperAdminBypass: options.allowSuperAdminBypass ?? false
+  };
+}
+async function readPackageMetadata(projectPath) {
+  const packageJsonPath = join(projectPath, "package.json");
+  if (!await pathExists$1(packageJsonPath)) return {};
+  try {
+    const json = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+    return {
+      name: typeof json.name === "string" ? json.name : void 0,
+      version: typeof json.version === "string" ? json.version : void 0,
+      json
+    };
+  } catch {
+    return {};
+  }
+}
+async function pathExists$1(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isManifestLike(value) {
+  return !!value && typeof value === "object" && !!value.objects && typeof value.objects === "object";
+}
+function scanErrorToDiagnostic(error) {
+  return {
+    severity: error.severity,
+    message: error.message,
+    filePath: error.filePath,
+    line: error.line,
+    column: error.column
+  };
+}
+function sanitizePath$1(projectPath, filePath) {
+  const absolute = isAbsolute(filePath) ? filePath : resolve(projectPath, filePath);
+  const relativePath = relative(projectPath, absolute);
+  if (!relativePath.startsWith("..")) {
+    return relativePath || filePath;
+  }
+  return filePath;
+}
+function stringFromConfig(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function arrayFromConfig(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+}
+function compactObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function messageFromError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+const SOURCE_EXTENSIONS = /\.(tsx?|jsx?|svelte)$/;
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".git",
+  ".smrt",
+  ".svelte-kit",
+  "coverage"
+]);
+const DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+const SMRT_PACKAGE_PREFIX = "@happyvertical/smrt-";
+const HAPPYVERTICAL_PACKAGE_PREFIX = "@happyvertical/";
+async function reviewSmrtProject(args) {
+  const projectPath = resolve(args.directory ?? args.rootDir ?? process.cwd());
+  if (!await pathExists(projectPath)) {
+    return JSON.stringify(
+      {
+        projectPath,
+        packageCount: 0,
+        packages: [],
+        findings: [],
+        summary: { high: 0, medium: 0, low: 0 },
+        diagnostics: [
+          {
+            severity: "warning",
+            message: `Project directory does not exist: ${projectPath}`
+          }
+        ]
+      },
+      null,
+      2
+    );
+  }
+  const packageContexts = await buildPackageContexts(projectPath);
+  const sourceFiles = await listSourceFiles(projectPath, packageContexts);
+  await attachSourceFiles(sourceFiles, packageContexts, projectPath);
+  const findings = limitFindings(
+    [
+      ...findMissingHappyVerticalDependencies(packageContexts),
+      ...findCustomManifestGeneration(sourceFiles, projectPath),
+      ...findDirectStorageBypasses(sourceFiles, packageContexts, projectPath),
+      ...findCustomHttpShells(sourceFiles, packageContexts, projectPath),
+      ...findLocalAuthTenancy(sourceFiles, packageContexts, projectPath),
+      ...findUiShellDrift(packageContexts, projectPath),
+      ...findMissingManifestArtifacts(
+        sourceFiles,
+        packageContexts,
+        projectPath
+      )
+    ],
+    args.maxFindings
+  );
+  const packages = packageContexts.map(packageInventory).sort((left, right) => left.path.localeCompare(right.path));
+  const summary = summarizeFindings(findings);
+  return JSON.stringify(
+    {
+      projectPath,
+      packageCount: packages.length,
+      packages,
+      findings: args.includeSourceEvidence === false ? findings.map(({ evidence: _evidence, ...finding }) => finding) : findings,
+      summary,
+      referenceChecks: [
+        "Prefer SMRT scanner/runtime manifests over custom manifest builders.",
+        "Prefer SvelteKit plus @happyvertical/smrt-svelte for app shells.",
+        "Prefer @happyvertical/sql and @happyvertical/files/assets/content over direct durable node:fs storage.",
+        "Prefer smrt-users, smrt-tenancy, and profile/audit packages over local static auth seams."
+      ],
+      suggestedFollowUpIssues: findings.map((finding) => ({
+        title: finding.suggestedIssueTitle,
+        severity: finding.severity,
+        area: finding.area
+      }))
+    },
+    null,
+    2
+  );
+}
+async function buildPackageContexts(projectPath) {
+  const packageJsonPaths = await listPackageJsonFiles(projectPath);
+  const contexts = await Promise.all(
+    packageJsonPaths.map(async (packageJsonPath) => {
+      const json = JSON.parse(
+        await readFile(packageJsonPath, "utf-8")
+      );
+      const directory = dirname(packageJsonPath);
+      return {
+        directory,
+        relativePath: relative(projectPath, directory) || ".",
+        packageJsonPath,
+        json,
+        dependencies: collectDependencies(json),
+        scripts: isRecord(json.scripts) ? json.scripts : {},
+        imports: /* @__PURE__ */ new Map(),
+        sourceFiles: []
+      };
+    })
+  );
+  if (contexts.length === 0) {
+    contexts.push({
+      directory: projectPath,
+      relativePath: ".",
+      packageJsonPath: join(projectPath, "package.json"),
+      json: {},
+      dependencies: /* @__PURE__ */ new Set(),
+      scripts: {},
+      imports: /* @__PURE__ */ new Map(),
+      sourceFiles: []
+    });
+  }
+  return contexts.sort(
+    (left, right) => left.directory.length - right.directory.length
+  );
+}
+async function listPackageJsonFiles(projectPath) {
+  const files = [];
+  await visit(projectPath, async (filePath, entryName) => {
+    if (entryName === "package.json") files.push(filePath);
+  });
+  return files;
+}
+async function listSourceFiles(projectPath, packages) {
+  const files = [];
+  await visit(projectPath, async (filePath, entryName) => {
+    if (!SOURCE_EXTENSIONS.test(entryName)) return;
+    if (entryName.endsWith(".d.ts") || entryName.endsWith(".test.ts") || entryName.endsWith(".spec.ts")) {
+      return;
+    }
+    const packageDir = findOwningPackage(filePath, packages).directory;
+    const content = await readFile(filePath, "utf-8");
+    files.push({ path: filePath, packageDir, content });
+  });
+  return files;
+}
+async function attachSourceFiles(sourceFiles, packages, projectPath) {
+  for (const sourceFile of sourceFiles) {
+    const owner = packages.find(
+      (pkg) => pkg.directory === sourceFile.packageDir
+    );
+    if (!owner) continue;
+    owner.sourceFiles.push(sourceFile);
+    for (const importedPackage of extractImports(sourceFile.content)) {
+      if (!importedPackage.startsWith(HAPPYVERTICAL_PACKAGE_PREFIX)) continue;
+      const evidence = {
+        filePath: relative(projectPath, sourceFile.path),
+        line: lineNumber(sourceFile.content, importedPackage),
+        detail: `Imports ${importedPackage}`
+      };
+      const existing = owner.imports.get(importedPackage) ?? [];
+      existing.push(evidence);
+      owner.imports.set(importedPackage, existing);
+    }
+  }
+}
+function findMissingHappyVerticalDependencies(packages) {
+  return packages.flatMap((pkg) => {
+    const ownName = typeof pkg.json.name === "string" ? pkg.json.name : void 0;
+    const missing = Array.from(pkg.imports.keys()).filter(
+      (importedPackage) => importedPackage !== ownName && !pkg.dependencies.has(importedPackage)
+    );
+    if (missing.length === 0) return [];
+    const hasSmrtMissing = missing.some(
+      (name) => name.startsWith(SMRT_PACKAGE_PREFIX)
+    );
+    return [
+      {
+        severity: hasSmrtMissing ? "high" : "medium",
+        area: "dependencies",
+        code: "missing-happyvertical-dependencies",
+        title: `${packageLabel(pkg)} imports HappyVertical packages that package.json does not declare`,
+        evidence: missing.flatMap((name) => pkg.imports.get(name) ?? []),
+        recommendation: "Declare every imported @happyvertical package in the owning package manifest so downstream installs and generated knowledge stay reproducible.",
+        suggestedIssueTitle: `Declare missing HappyVertical dependencies in ${packageLabel(pkg)}`
+      }
+    ];
+  });
+}
+function findCustomManifestGeneration(sourceFiles, projectPath) {
+  return sourceFiles.filter(
+    (file) => /manifest\.json/.test(file.content) && /objects\s*:/.test(file.content) && /\b(writeFile|writeFileSync)\b/.test(file.content) && !/@happyvertical\/smrt-scanner/.test(file.content)
+  ).map((file) => ({
+    severity: "high",
+    area: "manifest",
+    code: "custom-object-manifest-generation",
+    title: "Custom SMRT object manifest generation detected",
+    evidence: [
+      {
+        filePath: relative(projectPath, file.path),
+        line: lineNumber(file.content, "manifest.json"),
+        detail: "Writes a manifest.json object inventory outside the SMRT scanner/runtime path."
+      }
+    ],
+    recommendation: "Use the SMRT scanner/runtime manifest path so defaults, relationships, schemas, tenant fields, and cross-package references match framework behavior.",
+    suggestedIssueTitle: "Replace custom object manifest generation with SMRT scanner/runtime manifest generation"
+  }));
+}
+function findDirectStorageBypasses(sourceFiles, packages, projectPath) {
+  return sourceFiles.flatMap((file) => {
+    const owner = findOwningPackage(file.path, packages);
+    const usesFs = /from\s+['"](?:node:fs|node:fs\/promises|fs|fs\/promises)['"]|require\(['"](?:node:fs|node:fs\/promises|fs|fs\/promises)['"]\)/.test(
+      file.content
+    );
+    const writesDurableData = /\b(writeFile|appendFile|mkdir|rm|rename)\b/.test(file.content) && /(\.json|data|storage|persist|cache|db)/i.test(file.content);
+    const usesDirectSql = /from\s+['"](?:better-sqlite3|sqlite3|pg|mysql2?|knex|drizzle-orm)['"]/.test(
+      file.content
+    );
+    if ((!usesFs || !writesDurableData) && !usesDirectSql) return [];
+    const hasApprovedStorage = owner.dependencies.has("@happyvertical/sql") || owner.dependencies.has("@happyvertical/files") || owner.dependencies.has("@happyvertical/smrt-assets") || owner.dependencies.has("@happyvertical/smrt-content");
+    if (hasApprovedStorage) return [];
+    return [
+      {
+        severity: "medium",
+        area: "storage",
+        code: "direct-storage-bypass",
+        title: `${packageLabel(owner)} appears to bypass HappyVertical storage packages`,
+        evidence: [
+          {
+            filePath: relative(projectPath, file.path),
+            line: lineNumber(
+              file.content,
+              usesDirectSql ? "sqlite" : "writeFile"
+            ),
+            detail: usesDirectSql ? "Imports a direct SQL/storage library without @happyvertical/sql." : "Uses node:fs-style durable writes without @happyvertical/files/assets/content."
+          }
+        ],
+        recommendation: "Route durable data through @happyvertical/sql, @happyvertical/files, SMRT assets, or SMRT content unless this is explicitly build-only tooling.",
+        suggestedIssueTitle: `Review direct storage usage in ${packageLabel(owner)}`
+      }
+    ];
+  });
+}
+function findCustomHttpShells(sourceFiles, packages, projectPath) {
+  const evidenceByPackage = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (pkg.dependencies.has("@sveltejs/kit")) continue;
+    const routerDependencies = ["express", "fastify", "hono", "koa"].filter(
+      (dep) => pkg.dependencies.has(dep)
+    );
+    if (routerDependencies.length === 0) continue;
+    appendEvidence(evidenceByPackage, pkg, {
+      filePath: relative(projectPath, pkg.packageJsonPath),
+      detail: `Declares custom router package(s): ${routerDependencies.join(", ")}.`
+    });
+  }
+  for (const file of sourceFiles) {
+    const owner = findOwningPackage(file.path, packages);
+    if (owner.dependencies.has("@sveltejs/kit")) continue;
+    const usesNodeHttp = /from\s+['"](?:node:http|http|node:https|https)['"]|createServer\s*\(/.test(
+      file.content
+    );
+    if (!usesNodeHttp) continue;
+    appendEvidence(evidenceByPackage, owner, {
+      filePath: relative(projectPath, file.path),
+      line: lineNumber(file.content, "createServer"),
+      detail: "Custom HTTP routing found without the SvelteKit/SMRT app-shell dependency pattern."
+    });
+  }
+  return Array.from(evidenceByPackage.entries()).map(([owner, evidence]) => ({
+    severity: "medium",
+    area: "api-shell",
+    code: "custom-http-shell",
+    title: `${packageLabel(owner)} uses a custom HTTP shell`,
+    evidence,
+    recommendation: "Compare the app shell against the Anytown/Ergot SvelteKit + SMRT shell pattern before adding custom HTTP infrastructure.",
+    suggestedIssueTitle: `Align ${packageLabel(owner)} app shell with SMRT/SvelteKit conventions`
+  }));
+}
+function appendEvidence(evidenceByPackage, pkg, evidence) {
+  const existing = evidenceByPackage.get(pkg);
+  if (existing) {
+    existing.push(evidence);
+    return;
+  }
+  evidenceByPackage.set(pkg, [evidence]);
+}
+function findLocalAuthTenancy(sourceFiles, packages, projectPath) {
+  return sourceFiles.flatMap((file) => {
+    const owner = findOwningPackage(file.path, packages);
+    const pathSignal = /(auth|tenant|audit|session|rbac|user)/i.test(file.path);
+    const codeSignal = /\b(tenantId|tenant|role|permission|session|auditLog|apiKey)\b/.test(
+      file.content
+    );
+    if (!pathSignal || !codeSignal) return [];
+    const hasApprovedPackages = owner.dependencies.has("@happyvertical/smrt-users") || owner.dependencies.has("@happyvertical/smrt-tenancy") || owner.dependencies.has("@happyvertical/smrt-profiles");
+    if (hasApprovedPackages) return [];
+    return [
+      {
+        severity: "medium",
+        area: "auth-tenancy",
+        code: "local-auth-tenancy",
+        title: `${packageLabel(owner)} contains local auth/tenancy/audit logic`,
+        evidence: [
+          {
+            filePath: relative(projectPath, file.path),
+            line: lineNumber(file.content, "tenant"),
+            detail: "Auth, tenancy, session, role, or audit terminology appears without smrt-users/smrt-tenancy/smrt-profiles dependencies."
+          }
+        ],
+        recommendation: "Add explicit adapters to smrt-users, smrt-tenancy, and profile/audit models or document why this local implementation is intentionally isolated.",
+        suggestedIssueTitle: `Review auth and tenancy adapters in ${packageLabel(owner)}`
+      }
+    ];
+  });
+}
+function findUiShellDrift(packages, projectPath) {
+  return packages.flatMap((pkg) => {
+    const hasUiSource = pkg.sourceFiles.some(
+      (file) => file.path.endsWith(".svelte")
+    );
+    const likelyUiPackage = hasUiSource || /(?:web|ui|app|site|frontend)/i.test(packageLabel(pkg)) || pkg.dependencies.has("svelte") || pkg.dependencies.has("vite");
+    if (!likelyUiPackage) return [];
+    if (pkg.dependencies.has("@happyvertical/smrt-svelte")) return [];
+    return [
+      {
+        severity: "low",
+        area: "ui-shell",
+        code: "missing-smrt-svelte-shell",
+        title: `${packageLabel(pkg)} looks like UI work without @happyvertical/smrt-svelte`,
+        evidence: [
+          {
+            filePath: relative(projectPath, pkg.packageJsonPath),
+            detail: "UI-facing package does not declare @happyvertical/smrt-svelte."
+          }
+        ],
+        recommendation: "Use @happyvertical/smrt-svelte and the SvelteKit shell pattern for downstream app UI unless this package is intentionally framework-agnostic.",
+        suggestedIssueTitle: `Check SMRT Svelte shell alignment for ${packageLabel(pkg)}`
+      }
+    ];
+  });
+}
+function findMissingManifestArtifacts(sourceFiles, packages, projectPath) {
+  return packages.flatMap((pkg) => {
+    const hasSmrtSource = pkg.sourceFiles.some(
+      (file) => /@smrt\s*\(/.test(file.content)
+    );
+    if (!hasSmrtSource) return [];
+    const hasManifest = sourceFiles.some(
+      (file) => file.packageDir === pkg.directory && /@happyvertical\/smrt-scanner/.test(file.content)
+    ) || pathExistsSyncHint(join(pkg.directory, ".smrt", "manifest.json")) || pathExistsSyncHint(join(pkg.directory, "dist", "manifest.json"));
+    if (hasManifest) return [];
+    return [
+      {
+        severity: "low",
+        area: "manifest",
+        code: "missing-generated-manifest-artifact",
+        title: `${packageLabel(pkg)} has @smrt objects but no generated manifest artifact was found`,
+        evidence: [
+          {
+            filePath: relative(projectPath, pkg.packageJsonPath),
+            detail: "No .smrt/manifest.json or dist/manifest.json was visible during review."
+          }
+        ],
+        recommendation: "Run the package build/test manifest generation path and verify it uses the SMRT scanner/runtime manifest pipeline.",
+        suggestedIssueTitle: `Verify SMRT manifest generation for ${packageLabel(pkg)}`
+      }
+    ];
+  });
+}
+async function visit(dir, onFile) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      await visit(fullPath, onFile);
+      continue;
+    }
+    if (entry.isFile()) await onFile(fullPath, entry.name);
+  }
+}
+function collectDependencies(packageJson) {
+  const dependencies = /* @__PURE__ */ new Set();
+  for (const sectionName of DEPENDENCY_SECTIONS) {
+    const section = packageJson[sectionName];
+    if (!isRecord(section)) continue;
+    for (const dependencyName of Object.keys(section)) {
+      dependencies.add(dependencyName);
+    }
+  }
+  return dependencies;
+}
+function extractImports(content) {
+  const imports = /* @__PURE__ */ new Set();
+  const patterns = [
+    /(?:import|export)\s+(?:type\s+)?(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/g,
+    /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of content.matchAll(pattern)) {
+      const imported = normalizePackageImport(match[1]);
+      if (imported) imports.add(imported);
+    }
+  }
+  return Array.from(imports);
+}
+function normalizePackageImport(value) {
+  if (!value || value.startsWith(".") || value.startsWith("/"))
+    return void 0;
+  if (value.startsWith("@")) {
+    const [scope, name] = value.split("/");
+    return scope && name ? `${scope}/${name}` : value;
+  }
+  return value.split("/")[0];
+}
+function findOwningPackage(filePath, packages) {
+  const normalized = resolve(filePath);
+  const matches = packages.filter(
+    (pkg) => normalized === pkg.directory || normalized.startsWith(`${pkg.directory}${sep}`)
+  ).sort((left, right) => right.directory.length - left.directory.length);
+  return matches[0] ?? packages[0];
+}
+function packageInventory(pkg) {
+  const declaredHappyVerticalDependencies = Array.from(pkg.dependencies).filter((dependency) => dependency.startsWith(HAPPYVERTICAL_PACKAGE_PREFIX)).sort();
+  const importedHappyVerticalPackages = Array.from(pkg.imports.keys()).sort();
+  const ownName = typeof pkg.json.name === "string" ? pkg.json.name : void 0;
+  return {
+    name: packageLabel(pkg),
+    path: pkg.relativePath,
+    private: typeof pkg.json.private === "boolean" ? pkg.json.private : void 0,
+    scripts: Object.keys(pkg.scripts).sort(),
+    declaredHappyVerticalDependencies,
+    importedHappyVerticalPackages,
+    missingHappyVerticalDependencies: importedHappyVerticalPackages.filter(
+      (name) => name !== ownName && !pkg.dependencies.has(name)
+    ),
+    hasSvelteKit: pkg.dependencies.has("@sveltejs/kit"),
+    hasSmrtSvelte: pkg.dependencies.has("@happyvertical/smrt-svelte")
+  };
+}
+function summarizeFindings(findings) {
+  return findings.reduce(
+    (summary, finding) => {
+      summary[finding.severity]++;
+      return summary;
+    },
+    { high: 0, medium: 0, low: 0 }
+  );
+}
+function limitFindings(findings, maxFindings) {
+  const sorted = findings.sort(
+    (left, right) => severityRank(left.severity) - severityRank(right.severity) || left.area.localeCompare(right.area) || left.title.localeCompare(right.title)
+  );
+  return maxFindings && maxFindings > 0 ? sorted.slice(0, maxFindings) : sorted;
+}
+function severityRank(severity) {
+  return severity === "high" ? 0 : severity === "medium" ? 1 : 2;
+}
+function packageLabel(pkg) {
+  return typeof pkg.json.name === "string" ? pkg.json.name : pkg.relativePath;
+}
+function lineNumber(content, needle) {
+  const index = content.indexOf(needle);
+  if (index < 0) return void 0;
+  return content.slice(0, index).split("\n").length;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pathExistsSyncHint(path) {
+  return existsSync(path);
+}
+
+const SERVER_NAME = "smrt-dev-mcp";
+const SERVER_VERSION = readPackageVersion();
+const DEBUG = process.env.DEBUG === "true";
+const REVIEW_SKILL_NAME = "smrt-code-review";
+const REVIEW_SKILL_URI = `smrt-dev-mcp://agent-skills/${REVIEW_SKILL_NAME}`;
+const DOMAIN_CODE_REVIEW_PROMPT = "domain-code-review";
+const DOMAIN_ARCHITECTURE_PROMPT = "domain-architecture";
+const KNOWLEDGE_PROJECT_URI = "smrt://knowledge/project";
+const KNOWLEDGE_PACKAGE_PREFIX = "smrt://knowledge/package/";
+const TOOLS = [
+  // Code Generation Tools
+  {
+    name: "generate-smrt-class",
+    description: "Generate a complete SMRT class with @smrt() decorator",
+    inputSchema: {
+      type: "object",
+      properties: {
+        className: {
+          type: "string",
+          description: "Name of the class (PascalCase)"
+        },
+        properties: {
+          type: "array",
+          description: "Array of property definitions",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: {
+                type: "string",
+                enum: [
+                  "text",
+                  "integer",
+                  "decimal",
+                  "boolean",
+                  "datetime",
+                  "json"
+                ]
+              },
+              required: { type: "boolean" },
+              nullable: { type: "boolean" },
+              description: { type: "string" },
+              defaultValue: {
+                oneOf: [
+                  { type: "string" },
+                  { type: "number" },
+                  { type: "boolean" },
+                  { type: "object" },
+                  { type: "null" }
+                ]
+              }
+            },
+            required: ["name", "type"]
+          }
+        },
+        baseClass: {
+          type: "string",
+          enum: ["SmrtObject", "SmrtCollection"],
+          default: "SmrtObject"
+        },
+        template: {
+          type: "string",
+          enum: [
+            "basic",
+            "global-catalog",
+            "optional-catalog",
+            "tenant-project-object",
+            "tenant-event-log-object",
+            "cross-package-reference"
+          ],
+          default: "basic"
+        },
+        tableName: { type: "string" },
+        conflictColumns: {
+          type: "array",
+          items: { type: "string" }
+        },
+        tenantScoped: {
+          oneOf: [
+            { type: "boolean" },
+            {
+              type: "object",
+              properties: {
+                mode: { type: "string", enum: ["required", "optional"] },
+                field: { type: "string" },
+                autoFilter: { type: "boolean" },
+                autoPopulate: { type: "boolean" },
+                allowSuperAdminBypass: { type: "boolean" }
+              }
+            }
+          ]
+        },
+        includeTenantIdField: { type: "boolean" },
+        relationships: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: {
+                type: "string",
+                enum: [
+                  "foreignKey",
+                  "crossPackageRef",
+                  "oneToMany",
+                  "manyToMany"
+                ]
+              },
+              related: { type: "string" },
+              required: { type: "boolean" },
+              nullable: { type: "boolean" },
+              description: { type: "string" },
+              validate: { type: "boolean" },
+              foreignKey: { type: "string" },
+              through: { type: "string" },
+              sourceKey: { type: "string" },
+              targetKey: { type: "string" }
+            },
+            required: ["name", "type", "related"]
+          }
+        },
+        includeCompanionSnippets: { type: "boolean", default: false },
+        includeApiConfig: { type: "boolean", default: true },
+        includeMcpConfig: { type: "boolean", default: true },
+        includeCliConfig: { type: "boolean", default: true }
+      },
+      required: ["className", "properties"]
+    }
+  },
+  // Project Introspection Tools
+  {
+    name: "introspect-project",
+    description: "Scan current directory for SMRT objects",
+    inputSchema: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "Project directory (default: cwd)"
+        },
+        manifestPath: {
+          type: "string",
+          description: "Optional manifest path. Defaults to .smrt/manifest.json, dist/manifest.json, then source scanning."
+        },
+        includeFields: {
+          type: "boolean",
+          description: "Include field details"
+        },
+        includeRelationships: {
+          type: "boolean",
+          description: "Analyze relationships"
+        },
+        includeMethods: {
+          type: "boolean",
+          description: "Include public method details"
+        }
+      }
+    }
+  },
+  {
+    name: "review-smrt-project",
+    description: "Advisory ecosystem alignment review for downstream SMRT projects",
+    inputSchema: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "Project directory (default: cwd)"
+        },
+        rootDir: {
+          type: "string",
+          description: "Compatibility alias for directory"
+        },
+        includeSourceEvidence: {
+          type: "boolean",
+          description: "Include file and line evidence in findings",
+          default: true
+        },
+        maxFindings: {
+          type: "number",
+          description: "Optional maximum number of findings to return"
+        }
+      }
+    }
+  },
+  {
+    name: "reflect-knowledge",
+    description: "Report deterministic SMRT + HappyVertical SDK knowledge coverage and freshness",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: {
+          type: "string",
+          description: "Project root directory (default: cwd)"
+        }
+      }
+    }
+  },
+  {
+    name: "reflect-domain-knowledge",
+    description: "Report domain-scoped SMRT knowledge artifacts, SDK packages, and freshness",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        scope: {
+          type: "string",
+          enum: ["project", "local", "package", "sdk"],
+          default: "project"
+        },
+        package: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "check-knowledge-freshness",
+    description: "Run deterministic freshness checks for SMRT agent knowledge",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        changed: {
+          type: "boolean",
+          description: "Limit stale-pattern checks to changed files"
+        },
+        strict: {
+          type: "boolean",
+          description: "Treat stale-pattern findings as errors"
+        }
+      }
+    }
+  },
+  {
+    name: "check-domain-knowledge",
+    description: "Run deterministic freshness checks for domain knowledge artifacts",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        changed: { type: "boolean" },
+        strict: { type: "boolean" },
+        scope: {
+          type: "string",
+          enum: ["project", "local", "package", "sdk"],
+          default: "project"
+        },
+        package: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "build-review-context",
+    description: "Build model-ready SMRT review context from changed files and optional focus text",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        changedFiles: { type: "array", items: { type: "string" } },
+        focus: { type: "string" },
+        documentation: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "build-domain-review-context",
+    description: "Build domain-scoped model-ready SMRT review context and prompt bundle",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        changedFiles: { type: "array", items: { type: "string" } },
+        focus: { type: "string" },
+        documentation: { type: "string" },
+        scope: {
+          type: "string",
+          enum: ["project", "local", "package", "sdk"],
+          default: "project"
+        },
+        package: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "smrt-review",
+    description: 'Return deterministic review findings and/or a reusable model prompt bundle. For a formal downstream review, first call get-agent-skill with { "name": "smrt-code-review" } or load the smrt-code-review MCP prompt/resource.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        changedFiles: { type: "array", items: { type: "string" } },
+        focus: { type: "string" },
+        documentation: { type: "string" },
+        mode: {
+          type: "string",
+          enum: ["findings", "prompt-bundle", "both"],
+          default: "both"
+        }
+      }
+    }
+  },
+  {
+    name: "build-architecture-context",
+    description: "Build model-ready SMRT architecture context from an idea or documentation",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        idea: { type: "string" },
+        documentation: { type: "string" },
+        focus: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "build-domain-architecture-context",
+    description: "Build domain-scoped model-ready SMRT architecture context and prompt bundle",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        idea: { type: "string" },
+        documentation: { type: "string" },
+        focus: { type: "string" },
+        scope: {
+          type: "string",
+          enum: ["project", "local", "package", "sdk"],
+          default: "project"
+        },
+        package: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "smrt-architecture",
+    description: "Suggest SMRT and HappyVertical SDK packages and return an architecture prompt bundle",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootDir: { type: "string" },
+        idea: { type: "string" },
+        documentation: { type: "string" },
+        focus: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "list-agent-skills",
+    description: "List bundled harness-agnostic agent skills shipped with smrt-dev-mcp",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "get-agent-skill",
+    description: "Return a bundled harness-agnostic agent skill as Markdown plus optional references",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          enum: [REVIEW_SKILL_NAME],
+          description: "Bundled agent skill name"
+        },
+        includeReferences: {
+          type: "boolean",
+          default: true,
+          description: "Include referenced files with the skill bundle"
+        }
+      },
+      required: ["name"]
+    }
+  }
+];
+async function main() {
+  if (DEBUG) {
+    console.error(`[${SERVER_NAME}] Starting server v${SERVER_VERSION}`);
+  }
+  const server = new Server(
+    {
+      name: SERVER_NAME,
+      version: SERVER_VERSION
+    },
+    {
+      capabilities: {
+        prompts: {},
+        resources: {},
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    if (DEBUG) {
+      console.error(`[${SERVER_NAME}] ListTools request`);
+    }
+    return { tools: TOOLS };
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return {
+      prompts: [
+        {
+          name: REVIEW_SKILL_NAME,
+          title: "SMRT Code Review",
+          description: "Harness-agnostic downstream SMRT review procedure that uses smrt-dev-mcp deterministic context and prompt bundles."
+        },
+        {
+          name: DOMAIN_CODE_REVIEW_PROMPT,
+          title: "Domain Code Review",
+          description: "Model-ready domain-scoped SMRT code review prompt bundle.",
+          arguments: [
+            {
+              name: "rootDir",
+              description: "Project root directory. Defaults to server cwd.",
+              required: false
+            },
+            {
+              name: "changedFiles",
+              description: "Changed file paths as newline-separated, comma-separated, or JSON array text.",
+              required: false
+            },
+            {
+              name: "focus",
+              description: "Review focus text.",
+              required: false
+            },
+            {
+              name: "documentation",
+              description: "Additional documentation or notes.",
+              required: false
+            },
+            {
+              name: "scope",
+              description: "Knowledge scope: project, local, package, or sdk.",
+              required: false
+            },
+            {
+              name: "package",
+              description: "Package name or short package selector.",
+              required: false
+            }
+          ]
+        },
+        {
+          name: DOMAIN_ARCHITECTURE_PROMPT,
+          title: "Domain Architecture",
+          description: "Model-ready domain-scoped SMRT architecture planning prompt bundle.",
+          arguments: [
+            {
+              name: "rootDir",
+              description: "Project root directory. Defaults to server cwd.",
+              required: false
+            },
+            {
+              name: "idea",
+              description: "Architecture idea or product concept.",
+              required: false
+            },
+            {
+              name: "documentation",
+              description: "Additional documentation or notes.",
+              required: false
+            },
+            {
+              name: "focus",
+              description: "Planning focus text.",
+              required: false
+            },
+            {
+              name: "scope",
+              description: "Knowledge scope: project, local, package, or sdk.",
+              required: false
+            },
+            {
+              name: "package",
+              description: "Package name or short package selector.",
+              required: false
+            }
+          ]
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name } = request.params;
+    if (name === REVIEW_SKILL_NAME) {
+      return {
+        description: "Use this procedure when reviewing downstream SMRT projects.",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: renderAgentSkillMarkdown(REVIEW_SKILL_NAME)
+            }
+          }
+        ]
+      };
+    }
+    if (name === DOMAIN_CODE_REVIEW_PROMPT) {
+      const context = await buildReviewContext(
+        reviewPromptArguments(request.params.arguments)
+      );
+      return {
+        description: "Review downstream SMRT code with domain knowledge.",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: context.promptBundle.contextMarkdown
+            }
+          }
+        ]
+      };
+    }
+    if (name === DOMAIN_ARCHITECTURE_PROMPT) {
+      const context = await buildArchitectureContext(
+        architecturePromptArguments(request.params.arguments)
+      );
+      return {
+        description: "Plan a downstream SMRT project with domain knowledge.",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: context.promptBundle.contextMarkdown
+            }
+          }
+        ]
+      };
+    }
+    throw new McpError(ErrorCode.InvalidParams, `Unknown prompt: ${name}`);
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const index = await buildKnowledgeIndex();
+    return {
+      resources: [
+        {
+          uri: REVIEW_SKILL_URI,
+          name: REVIEW_SKILL_NAME,
+          title: "SMRT Code Review Skill",
+          description: "Bundled Markdown skill for downstream SMRT code reviews.",
+          mimeType: "text/markdown"
+        },
+        {
+          uri: KNOWLEDGE_PROJECT_URI,
+          name: "smrt-domain-knowledge-project",
+          title: "SMRT Domain Knowledge Project Index",
+          description: "Composed SMRT, downstream domain, and HappyVertical SDK knowledge index.",
+          mimeType: "application/json"
+        },
+        ...index.packages.map((pkg) => ({
+          uri: `${KNOWLEDGE_PACKAGE_PREFIX}${encodeURIComponent(pkg.name)}`,
+          name: `smrt-domain-knowledge-${pkg.name}`,
+          title: `SMRT Domain Knowledge: ${pkg.name}`,
+          description: "Package-scoped SMRT domain knowledge, generated surfaces, and authored context.",
+          mimeType: "application/json"
+        }))
+      ]
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri === REVIEW_SKILL_URI) {
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "text/markdown",
+            text: renderAgentSkillMarkdown(REVIEW_SKILL_NAME)
+          }
+        ]
+      };
+    }
+    if (uri === KNOWLEDGE_PROJECT_URI) {
+      const index = await buildKnowledgeIndex();
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(sanitizeKnowledgeIndex(index), null, 2)
+          }
+        ]
+      };
+    }
+    if (uri.startsWith(KNOWLEDGE_PACKAGE_PREFIX)) {
+      const packageName = decodeURIComponent(
+        uri.slice(KNOWLEDGE_PACKAGE_PREFIX.length)
+      );
+      const index = await buildKnowledgeIndex();
+      const pkg = index.packages.find((item) => item.name === packageName);
+      if (!pkg) {
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          `Unknown knowledge package: ${packageName}`
+        );
+      }
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(sanitizeKnowledgePackage(pkg), null, 2)
+          }
+        ]
+      };
+    }
+    throw new McpError(ErrorCode.InvalidParams, `Unknown resource: ${uri}`);
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (DEBUG) {
+      console.error(`[${SERVER_NAME}] CallTool: ${name}`);
+      console.error(
+        `[${SERVER_NAME}] Arguments:`,
+        JSON.stringify(args, null, 2)
+      );
+    }
+    try {
+      let result;
+      switch (name) {
+        case "generate-smrt-class":
+          result = await generateSmrtClass(args);
+          break;
+        case "introspect-project":
+          result = await introspectProject(args);
+          break;
+        case "review-smrt-project":
+          result = await reviewSmrtProject(args);
+          break;
+        case "reflect-knowledge": {
+          const index = await buildKnowledgeIndex(args);
+          const freshness = await checkKnowledgeFreshnessFromIndex(
+            index,
+            args
+          );
+          result = JSON.stringify(
+            {
+              rootDir: index.rootDir,
+              packageCount: index.packages.length,
+              smrtPackageCount: index.smrtPackages.length,
+              sdkPackageCount: index.sdkPackages.length,
+              relationshipsV2: index.relationshipsV2,
+              freshness
+            },
+            null,
+            2
+          );
+          break;
+        }
+        case "reflect-domain-knowledge": {
+          const index = await buildKnowledgeIndex(args);
+          const freshness = await checkKnowledgeFreshnessFromIndex(
+            index,
+            args
+          );
+          result = JSON.stringify(
+            {
+              rootDir: index.rootDir,
+              packageCount: index.packages.length,
+              smrtPackageCount: index.smrtPackages.length,
+              sdkPackageCount: index.sdkPackages.length,
+              domainKnowledgePackageCount: index.packages.filter(
+                (pkg) => pkg.hasDomainKnowledge
+              ).length,
+              missingDomainKnowledgePackages: index.packages.filter(
+                (pkg) => pkg.exportKeys.includes("./smrt-knowledge.json") && !pkg.hasDomainKnowledge
+              ).map((pkg) => pkg.name),
+              relationshipsV2: index.relationshipsV2,
+              freshness
+            },
+            null,
+            2
+          );
+          break;
+        }
+        case "check-knowledge-freshness":
+          result = JSON.stringify(
+            await checkKnowledgeFreshness(args),
+            null,
+            2
+          );
+          break;
+        case "check-domain-knowledge":
+          result = JSON.stringify(
+            await checkKnowledgeFreshness(args),
+            null,
+            2
+          );
+          break;
+        case "build-review-context":
+          result = JSON.stringify(
+            await buildReviewContext(args),
+            null,
+            2
+          );
+          break;
+        case "build-domain-review-context":
+          result = JSON.stringify(
+            await buildReviewContext(args),
+            null,
+            2
+          );
+          break;
+        case "smrt-review":
+          result = JSON.stringify(await smrtReview(args), null, 2);
+          break;
+        case "build-architecture-context":
+          result = JSON.stringify(
+            await buildArchitectureContext(args),
+            null,
+            2
+          );
+          break;
+        case "build-domain-architecture-context":
+          result = JSON.stringify(
+            await buildArchitectureContext(args),
+            null,
+            2
+          );
+          break;
+        case "smrt-architecture":
+          result = JSON.stringify(await smrtArchitecture(args), null, 2);
+          break;
+        case "list-agent-skills":
+          result = JSON.stringify({ skills: listAgentSkills() }, null, 2);
+          break;
+        case "get-agent-skill":
+          result = JSON.stringify(await getAgentSkill(args), null, 2);
+          break;
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: result
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`[${SERVER_NAME}] Error:`, error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error executing tool ${name}: ${errorMessage}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  if (DEBUG) {
+    console.error(`[${SERVER_NAME}] Server connected via stdio`);
+  }
+  process.on("SIGINT", async () => {
+    if (DEBUG) {
+      console.error(`[${SERVER_NAME}] Shutting down...`);
+    }
+    await server.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    if (DEBUG) {
+      console.error(`[${SERVER_NAME}] Shutting down...`);
+    }
+    await server.close();
+    process.exit(0);
+  });
+}
+function isEntrypoint() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(entry);
+  } catch {
+    return import.meta.url === pathToFileURL(entry).href;
+  }
+}
+function readPackageVersion() {
+  try {
+    const packageRoot = dirname(fileURLToPath(import.meta.url));
+    const packageJsonPath = join(packageRoot, "..", "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function renderAgentSkillMarkdown(name) {
+  const skill = getAgentSkill({ name, includeReferences: true });
+  const references = skill.referenceFiles.map(
+    (file) => `## Reference: ${file.path}
+
+${file.content.trim()}`
+  );
+  return [skill.skillMarkdown.trim(), ...references].join("\n\n");
+}
+function reviewPromptArguments(args) {
+  return compactRecord({
+    rootDir: args?.rootDir,
+    changedFiles: parseStringList(args?.changedFiles),
+    focus: args?.focus,
+    documentation: args?.documentation,
+    scope: args?.scope,
+    package: args?.package
+  });
+}
+function architecturePromptArguments(args) {
+  return compactRecord({
+    rootDir: args?.rootDir,
+    idea: args?.idea,
+    documentation: args?.documentation,
+    focus: args?.focus,
+    scope: args?.scope,
+    package: args?.package
+  });
+}
+function parseStringList(value) {
+  if (!value?.trim()) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((item) => typeof item === "string");
+    }
+  } catch {
+  }
+  return value.split(/[\n,]/).map((item) => item.trim()).filter(Boolean);
+}
+function compactRecord(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function sanitizeKnowledgeIndex(index) {
+  const packages = index.packages.map((pkg) => sanitizeKnowledgePackage(pkg));
+  return {
+    ...index,
+    rootDir: ".",
+    packages,
+    smrtPackages: packages.filter((pkg) => pkg.kind === "smrt"),
+    sdkPackages: packages.filter((pkg) => pkg.kind === "sdk")
+  };
+}
+function sanitizeKnowledgePackage(pkg) {
+  const { directory: _directory, objects, ...rest } = pkg;
+  return {
+    ...rest,
+    objects: objects.map((object) => ({
+      ...object,
+      filePath: sanitizePath(object.filePath)
+    }))
+  };
+}
+function sanitizePath(path) {
+  if (!path) return path;
+  if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path)) {
+    return "<absolute-path>";
+  }
+  return path;
+}
+if (isEntrypoint()) {
+  main().catch((error) => {
+    console.error(`[${SERVER_NAME}] Fatal error:`, error);
+    process.exit(1);
+  });
+}
+
+export { SERVER_VERSION, TOOLS };
+//# sourceMappingURL=index.js.map