@smartmemory/compose 0.1.6-beta → 0.1.7-beta

package/server/compose-mcp.js

@@ -56,6 +56,8 @@ import {
   toolGetJournalEntries,
   toolRecordCompletion,
   toolGetCompletions,
+  toolValidateFeature,
+  toolValidateProject,
 } from './compose-mcp-tools.js';
 
 // ---------------------------------------------------------------------------
@@ -322,6 +324,30 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'validate_feature',
+    description: 'Cross-check a single feature against ROADMAP, vision-state, feature.json, folder contents, linked artifacts, and cross-references. Returns structured findings with severity (error/warning/info). FEATURE_NOT_FOUND emitted as a finding (not thrown) when the code matches strict regex but exists in no source.',
+    inputSchema: {
+      type: 'object',
+      required: ['feature_code'],
+      properties: {
+        feature_code: { type: 'string', description: 'Strict feature code, e.g. "COMP-MCP-VALIDATE"' },
+        external_prefixes: { type: 'array', items: { type: 'string' }, description: 'Code prefixes (e.g. ["STRAT-"]) treated as external; downgrades ORPHAN_FOLDER to info' },
+        feature_json_mode: { type: 'boolean', description: 'Default true. Set false to skip feature.json comparisons in legacy projects.' },
+      },
+    },
+  },
+  {
+    name: 'validate_project',
+    description: 'Run validate_feature for every code in vision-state, ROADMAP, and folders, plus cross-cutting checks (orphan folders, dangling cross-refs, CHANGELOG references, journal index drift). Returns the union of all findings.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        external_prefixes: { type: 'array', items: { type: 'string' } },
+        feature_json_mode: { type: 'boolean' },
+      },
+    },
+  },
 
   // -------------------------------------------------------------------------
   // Linker — COMP-MCP-ARTIFACT-LINKER
@@ -554,6 +580,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'get_journal_entries':      result = await toolGetJournalEntries(args); break;
       case 'record_completion':        result = await toolRecordCompletion(args); break;
       case 'get_completions':          result = await toolGetCompletions(args); break;
+      case 'validate_feature':         result = await toolValidateFeature(args); break;
+      case 'validate_project':         result = await toolValidateProject(args); break;
       // agent_run removed — STRAT-DEDUP-AGENTRUN v1. Use mcp__stratum__stratum_agent_run.
       default:
         return {

package/server/schema-validator.js

@@ -5,26 +5,43 @@ import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const SCHEMA_PATH = resolve(__dirname, '../contracts/comp-obs-contract.schema.json');
+const DEFAULT_SCHEMA_PATH = resolve(__dirname, '../contracts/comp-obs-contract.schema.json');
 
-let cached = null;
+// Per-path cache. Each entry: { schema, ajv }.
+const cache = new Map();
 
-function load() {
-  if (cached) return cached;
-  const schema = JSON.parse(readFileSync(SCHEMA_PATH, 'utf8'));
+function load(schemaPath = DEFAULT_SCHEMA_PATH) {
+  if (cache.has(schemaPath)) return cache.get(schemaPath);
+  const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
   const ajv = new Ajv({ strict: false, allErrors: true });
   addFormats(ajv);
   ajv.addSchema(schema);
-  cached = { schema, ajv };
-  return cached;
+  const entry = { schema, ajv };
+  cache.set(schemaPath, entry);
+  return entry;
+}
+
+/**
+ * Load (and cache) a schema by absolute path. Returns `{ schema, ajv }`.
+ * Used by code that wants to compile arbitrary `$ref`s against the schema
+ * without going through the SchemaValidator class.
+ */
+export function loadSchema(schemaPath) {
+  return load(schemaPath);
 }
 
 export class SchemaValidator {
-  constructor() {
-    const { schema, ajv } = load();
+  /**
+   * @param {string} [schemaPath] Absolute path to a JSON Schema file.
+   *   Default is the comp-obs-contract schema (back-compat for existing
+   *   callers that pass no args).
+   */
+  constructor(schemaPath = DEFAULT_SCHEMA_PATH) {
+    const { schema, ajv } = load(schemaPath);
     this.schema = schema;
     this.ajv = ajv;
     this._validators = new Map();
+    this._rootValidator = null;
   }
 
   _getValidator(defName) {
@@ -39,11 +56,35 @@ export class SchemaValidator {
     return v;
   }
 
+  /**
+   * Validate `obj` against `schema.definitions[defName]`. Used by the
+   * comp-obs-contract code paths.
+   */
   validate(defName, obj) {
     const v = this._getValidator(defName);
     const valid = v(obj);
     return { valid: !!valid, errors: valid ? [] : (v.errors || []) };
   }
+
+  /**
+   * Validate `obj` against the schema's root (no $defs/$ref indirection).
+   * Used by feature-json / vision-state / roadmap-row schemas, which are
+   * top-level shapes without nested definitions.
+   */
+  validateRoot(obj) {
+    if (!this._rootValidator) {
+      // ajv.getSchema by $id returns the root validator if the schema was
+      // added via addSchema (which load() does).
+      let v = this.schema.$id ? this.ajv.getSchema(this.schema.$id) : null;
+      if (!v) v = this.ajv.compile(this.schema);
+      this._rootValidator = v;
+    }
+    const v = this._rootValidator;
+    const valid = v(obj);
+    return { valid: !!valid, errors: valid ? [] : (v.errors || []) };
+  }
 }
 
+// Back-compat export — points at the comp-obs schema version. Existing
+// callers consuming SCHEMA_VERSION continue to work unchanged.
 export const SCHEMA_VERSION = load().schema.version;