@platformos/platformos-mcp-supervisor 0.1.0 → 0.2.1

package/dist/validate/validate-buffers.js

@@ -17,11 +17,12 @@ import { enrichDiagnostics } from '../enrich/enrich.js';
 import { lintDeadlineMs } from '../cost-model.js';
 import { TIMED_OUT, withDeadline } from '../deadline.js';
 import { runImpact } from '../impact/impact.js';
+import { canHaveDependants } from '../impact/dependants.js';
 import { createProjectScan } from '../impact/project-scan.js';
 import { runBatchLint, } from '../lint/lint-batch.js';
 import { assembleNotApplicableResult, assembleResult } from '../result/assemble.js';
 import { capToBudget } from '../result/response-budget.js';
-import { UNAVAILABLE_IMPACT } from '../result/impact-states.js';
+import { DISABLED_IMPACT, UNAVAILABLE_IMPACT } from '../result/impact-states.js';
 /** Read the process-wide docset and flatten it to the arrays enrichment takes. */
 async function resolveDocset() {
     const docset = getPlatformOSDocset();
@@ -65,11 +66,26 @@ export async function validateBuffers(ctx, buffers, overrides = {}) {
     // Computed ONCE and threaded to both the timer and the message that reports it, so the
     // two cannot disagree about the deadline a caller was held to.
     const lintDeadline = lintDeadlineMs(admittedBytes(lintable));
-    // Concurrently: the lint is the long pole and impact must hide behind it.
-    const [lint, impacts] = await Promise.all([
+    // The project SCAN overlaps the primary lint; the impact LINT PASSES cannot.
+    //
+    // `lintBuffers` overlays buffers into check-node's process-shared `App` and reverts them
+    // on the way out, and that App has no lock — so two lint passes running at once would
+    // corrupt each other. The scan is pure filesystem I/O and touches no App, which is what
+    // lets the expensive half of impact hide behind the lint anyway.
+    const scan = projectScan(ctx, lintable);
+    const [lint] = await Promise.all([
         lintWithDeadline(ctx, adapters, lintable, lintDeadline),
-        impactWithDeadline(ctx, adapters, lintable),
+        scan.warm(),
     ]);
+    // AFTER the primary lint, and never allowed to break it: the write gate is already
+    // decided by this point, so impact can only add to the answer or fail quietly.
+    //
+    // Turned off for this SERVER (`--no-impact`) it costs NOTHING: `projectScan` declines to
+    // read, and the two extra lint passes never start. `disabled` is its own status precisely
+    // so an agent does not read it as a failure worth retrying.
+    const impacts = ctx.impactEnabled === false
+        ? new Map(lintable.map((buffer) => [buffer.filePath, DISABLED_IMPACT()]))
+        : await impactWithDeadline(ctx, adapters, lintable, scan.scan);
     // The lint pass is what knows which buffers were not checked and why — it holds the
     // config AND the classifier. Folding its answer in here keeps ONE source of truth for
     // "is this file part of the app".
@@ -187,45 +203,83 @@ function admittedBytes(lintable) {
     return lintable.reduce((total, buffer) => total + Buffer.byteLength(buffer.content, 'utf8'), 0);
 }
 /**
- * Blast radius per lintable buffer.
+ * Impact per lintable buffer.
  *
- * ONE scan serves the whole batch: `createProjectScan` reads the project's edge sources
- * once, lazily and memoized, so N buffers cost one project read and N name filters. The
- * batch's own buffers are overlaid into it, so a caller a buffer has just added counts.
+ * ONE scan serves the whole batch: `createProjectScan` reads the project's edge sources once,
+ * LAZILY and memoized, so a batch whose buffers can have no dependants never reads the project
+ * at all, and one where some can pays a single read. The batch's own buffers are overlaid into
+ * it, so a call a buffer has just added counts.
  *
  * The set shares one tight deadline because impact is discardable enrichment —
  * `unavailable` already means "we don't know".
  */
-async function impactWithDeadline(ctx, adapters, lintable) {
+async function impactWithDeadline(ctx, adapters, lintable, scan) {
     const byFile = new Map();
     if (lintable.length === 0)
         return byFile;
-    const rootUri = pathUtils.normalize(pathUtils.toUri(ctx.projectDir));
-    const scan = createProjectScan(rootUri, NodeFileSystem, new Map(lintable.map((buffer) => [
-        pathUtils.normalize(pathUtils.toUri(toAbsoluteFilePath(ctx.projectDir, buffer.filePath))),
-        buffer.content,
-    ])));
-    const work = Promise.all(lintable.map(async (buffer) => {
-        const impact = await adapters
-            .impact({ projectDir: ctx.projectDir, filePath: buffer.filePath, content: buffer.content }, scan)
-            .catch((error) => {
-            ctx.log(`validate_code: blast-radius failed for ${buffer.filePath}: ${describe(error)}`);
-            return UNAVAILABLE_IMPACT();
-        });
-        return [buffer.filePath, impact];
-    }));
+    const work = adapters
+        .impact({
+        projectDir: ctx.projectDir,
+        buffers: lintable,
+        scan,
+        lint: adapters.lint,
+        docset: adapters.docset,
+        log: (message) => ctx.log(`validate_code: ${message}`),
+    })
+        .catch((error) => {
+        // ONE failure covers the whole changeset: the passes are shared, so a failure says
+        // nothing about any individual buffer.
+        ctx.log(`validate_code: impact failed: ${describe(error)}`);
+        return new Map();
+    });
     const outcome = await withDeadline(work, IMPACT_DEADLINE_MS);
     if (outcome === TIMED_OUT) {
-        observeAbandoned(ctx, work, 'blast-radius');
-        ctx.log(`validate_code: blast-radius exceeded ${IMPACT_DEADLINE_MS} ms, continuing without it`);
+        observeAbandoned(ctx, work, 'impact');
+        ctx.log(`validate_code: impact exceeded ${IMPACT_DEADLINE_MS} ms, continuing without it`);
         for (const buffer of lintable)
             byFile.set(buffer.filePath, UNAVAILABLE_IMPACT());
         return byFile;
     }
-    for (const [filePath, impact] of outcome)
-        byFile.set(filePath, impact);
+    // A buffer the pass did not answer for gets `unavailable` rather than a silent absence:
+    // `resultFor` would otherwise default it, and "we did not look" must not read as "we
+    // looked and found nothing".
+    for (const buffer of lintable) {
+        byFile.set(buffer.filePath, outcome.get(buffer.filePath) ?? UNAVAILABLE_IMPACT());
+    }
     return byFile;
 }
+/**
+ * The request's project scan, plus a handle to start reading it.
+ *
+ * Split so the read can be STARTED alongside the primary lint and awaited later: it is the
+ * expensive half of impact (~235 ms on a 2,615-file project) and pure filesystem I/O, so
+ * overlapping it with the lint's CPU costs nothing and races nothing.
+ */
+function projectScan(ctx, lintable) {
+    const rootUri = pathUtils.normalize(pathUtils.toUri(ctx.projectDir));
+    const scan = createProjectScan(rootUri, NodeFileSystem, new Map(lintable.map((buffer) => [
+        pathUtils.normalize(pathUtils.toUri(toAbsoluteFilePath(ctx.projectDir, buffer.filePath))),
+        buffer.content,
+    ])));
+    // Nothing in this changeset can HAVE dependants — every buffer is a YAML file, or sits in
+    // no platformOS directory — so impact will never consult the scan and reading the project
+    // would be pure waste. Decidable from the paths alone, before any I/O.
+    //
+    // A PERFORMANCE GUARD, NOT A CORRECTNESS ONE, which is why six mutants survive on it.
+    // `warm()` only PRE-warms: `scan.sources()` memoizes its promise and impact awaits that
+    // same promise itself, so inverting this buys a wasted read or a colder path, never a
+    // different answer. Nothing pins it — nor the `--no-impact` claim above, where what is
+    // tested is that the impact ADAPTER goes uncalled, not that the project read is skipped.
+    const worthReading = ctx.impactEnabled !== false &&
+        lintable.some((buffer) => canHaveDependants(pathUtils.normalize(pathUtils.toUri(toAbsoluteFilePath(ctx.projectDir, buffer.filePath))), rootUri));
+    return {
+        scan,
+        // A failed read is impact's problem, not the lint's: swallowed here so it cannot reject
+        // the `Promise.all` that the primary lint is riding in, and surfaced when impact awaits
+        // the same memoized promise itself.
+        warm: () => (worthReading ? scan.sources().catch(() => undefined) : Promise.resolve()),
+    };
+}
 /**
  * Attach a handler to work the deadline abandoned.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformos/platformos-mcp-supervisor",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "platformOS Model Context Protocol (MCP) server exposing validate_code for LLM agents.",
   "type": "module",
   "main": "dist/index.js",
@@ -26,9 +26,7 @@
     "access": "public",
     "@platformos:registry": "https://registry.npmjs.org"
   },
-  "bin": {
-    "platformos-mcp-supervisor": "dist/bin/platformos-mcp-supervisor.js"
-  },
+  "bin": "dist/bin/platformos-mcp-supervisor.js",
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts"
@@ -42,14 +40,17 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@platformos/liquid-html-parser": "0.1.0",
-    "@platformos/platformos-check-common": "1.0.0",
-    "@platformos/platformos-check-node": "1.0.0",
-    "@platformos/platformos-common": "0.1.0",
-    "@platformos/platformos-graph": "0.1.0",
-    "@platformos/platformos-language-server-common": "0.1.0",
-    "zod": "^3.23.8"
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@platformos/liquid-html-parser": "0.2.0",
+    "@platformos/platformos-check-common": "1.2.0",
+    "@platformos/platformos-check-node": "1.2.0",
+    "@platformos/platformos-common": "0.2.0",
+    "@platformos/platformos-graph": "0.2.1",
+    "@platformos/platformos-language-server-common": "0.1.2",
+    "zod": "^4.6.7"
   },
-  "devDependencies": {}
-}
+  "devDependencies": {
+    "typescript": "^5.9.0",
+    "vitest": "^4.0.18"
+  }
+}