@pathmode/cli 2.1.1 → 2.1.3

package/dist/index.js

@@ -16379,7 +16379,11 @@ const isGitHubAction = (!!process.env.GITHUB_ACTIONS || !!process.env.INPUT_FILE
 program
     .name('pathmode')
     .description('Pathmode CLI — Intent Engineering for AI product teams')
-    .version('2.1.1');
+    // Read from package.json rather than a literal: the two drifted once already (package.json
+    // said 2.1.2 while `--version` still answered 2.1.1), and a CLI that misreports its own
+    // version makes every "which build are you on?" bug report unanswerable. ncc inlines the
+    // JSON at build time, so this stays a single self-contained bundle.
+    .version((__nccwpck_require__(8330)/* .version */ .rE));
 // ============================================================
 // validate — Existing command (preserved)
 // ============================================================
@@ -16435,6 +16439,7 @@ program
 const readiness_1 = __nccwpck_require__(2804);
 const local_reader_1 = __nccwpck_require__(8963);
 const openspec_reader_1 = __nccwpck_require__(7290);
+const openspec_product_reader_1 = __nccwpck_require__(1615);
 /**
  * Resolve what to grade, in the order a person would expect: an explicit path wins, then a local
  * intent.md, then the OpenSpec change this repo is already working on. The last one is the point:
@@ -16446,8 +16451,10 @@ function resolvePreflightSubject(target) {
         if (!fs_1.default.existsSync(abs))
             return { error: `Nothing at ${abs}` };
         if (fs_1.default.statSync(abs).isDirectory()) {
-            const spec = (0, openspec_reader_1.openSpecChangeToSpec)({ id: path_1.default.basename(abs), dir: abs });
-            return { spec, source: abs, kind: 'openspec' };
+            const read = (0, openspec_product_reader_1.readOpenSpecChangeForPathmode)({ id: path_1.default.basename(abs), dir: abs });
+            if ((0, openspec_product_reader_1.isProductReadError)(read))
+                return { error: read.error };
+            return { spec: read.spec, source: abs, kind: 'openspec', notes: read.notes };
         }
         return { spec: (0, local_reader_1.parseIntentMarkdown)(fs_1.default.readFileSync(abs, 'utf-8')), source: abs, kind: 'intent.md' };
     }
@@ -16458,7 +16465,10 @@ function resolvePreflightSubject(target) {
     const ctx = (0, openspec_reader_1.detectOpenSpec)(process.cwd());
     if (ctx && ctx.changes.length === 1) {
         const change = ctx.changes[0];
-        return { spec: (0, openspec_reader_1.openSpecChangeToSpec)(change), source: change.dir, kind: 'openspec' };
+        const read = (0, openspec_product_reader_1.readOpenSpecChangeForPathmode)(change);
+        if ((0, openspec_product_reader_1.isProductReadError)(read))
+            return { error: read.error };
+        return { spec: read.spec, source: change.dir, kind: 'openspec', notes: read.notes };
     }
     if (ctx && ctx.changes.length > 1) {
         // Same rule the MCP resolver documents: never guess between changes. Directory order is
@@ -16476,13 +16486,17 @@ const preflight = async (target) => {
         console.error(chalk_1.default.red(`✗ ${resolved.error}`));
         process.exit(2);
     }
-    const { spec, source, kind } = resolved;
+    const { spec, source, kind, notes } = resolved;
     const verdict = (0, readiness_1.computeReadinessVerdict)(spec);
     // A relative path that climbs out of cwd is noise; show the real one.
     const relCandidate = path_1.default.relative(process.cwd(), source);
     const rel = !relCandidate || relCandidate.startsWith('..') ? source : relCandidate;
     console.log();
     console.log(chalk_1.default.dim(`Read ${kind === 'openspec' ? 'OpenSpec change' : 'intent.md'} at ${rel}`));
+    // Which document the verdict is actually about. Without this, a change carrying both an
+    // intent.md and a proposal.md gives no clue which one was graded.
+    for (const note of notes ?? [])
+        console.log(chalk_1.default.dim(`  ${note}`));
     console.log();
     // Show what was extracted per dimension BEFORE the verdict, so a wrong verdict is visibly
     // traceable to a wrong read rather than looking like a judgment about the author.
@@ -16870,6 +16884,7 @@ exports.readLocalIntents = readLocalIntents;
 exports.readIntentMeta = readIntentMeta;
 exports.readIntentFile = readIntentFile;
 exports.parseIntentMarkdown = parseIntentMarkdown;
+exports.stripHtmlComments = stripHtmlComments;
 const fs_1 = __importDefault(__nccwpck_require__(9896));
 const path_1 = __importDefault(__nccwpck_require__(6928));
 const gray_matter_1 = __importDefault(__nccwpck_require__(2702));
@@ -17025,7 +17040,7 @@ function frontmatterEdgeCases(v) {
 }
 function parseIntentMarkdown(content, fallbackId = 'intent') {
     const { data, content: rawBody } = (0, gray_matter_1.default)(content);
-    const body = stripFencedBlocks(rawBody);
+    const body = stripHtmlComments(stripFencedBlocks(rawBody));
     const sections = splitSections(body);
     const parsedVerification = extractVerification(sections);
     // The public schema allows verification as a flat string array; read it as manual checks
@@ -17108,6 +17123,28 @@ function stripFencedBlocks(body) {
     }
     return out.join('\n');
 }
+/**
+ * Remove HTML comments before any structural parsing. Template scaffolds ship guidance inside
+ * `<!-- ... -->`, and it is invisible when the markdown renders, so a reader that treats it as
+ * content is reading something the author never wrote.
+ *
+ * Found by running the published preflight over an untouched `pathmode-intent` scaffold: the
+ * Objective section held only a comment explaining what an objective is, that comment named "a
+ * role, a team, an operator, an agent", and those actor words carried it past
+ * `isObjectiveSpecific`. The scaffold reported a PASSING objective nobody had written. A first-run
+ * verdict that praises an empty template is worse than one that blocks, because it is confidently
+ * wrong at exactly the moment a new user is deciding whether to trust the tool at all.
+ *
+ * Applied AFTER `stripFencedBlocks`, so a `<!--` appearing as example content inside a fence is
+ * already gone and cannot open a comment that eats real prose. An unterminated comment swallows
+ * the rest of the document, matching both the fence rule above and what a markdown renderer does:
+ * the parser reads what the author sees.
+ */
+function stripHtmlComments(body) {
+    const withoutClosed = body.replace(/<!--[\s\S]*?-->/g, '');
+    const dangling = withoutClosed.indexOf('<!--');
+    return dangling === -1 ? withoutClosed : withoutClosed.slice(0, dangling);
+}
 function splitSections(body) {
     const sections = new Map();
     let current = null;
@@ -17330,6 +17367,178 @@ function hasVerificationContent(v) {
 }
 
 
+/***/ }),
+
+/***/ 1615:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+/**
+ * The product-judgment adapter for an OpenSpec change.
+ *
+ * WHY THIS IS A SEPARATE LAYER. `scripts/openspec-corpus/openspec-reader.ts` is a frozen
+ * instrument: the corpus measurements in docs/research/openspec-corpus-audit.md are only
+ * reproducible while it keeps reading exactly what it read then (that is also why it derives the
+ * title from the directory name rather than an H1, and why `openspec-import.ts` layers the nicer
+ * title on top instead of editing it). Teaching that file about `intent.md` would silently
+ * invalidate every recorded rate. So preference lives here, above it, and the reader stays
+ * untouched.
+ *
+ * WHAT THIS FIXES. The `pathmode-intent` schema writes the product judgment to a change-local
+ * `intent.md`, ahead of the proposal. The corpus reader has never heard of that file, so before
+ * this adapter existed, a change authored faithfully through our own schema graded as
+ * "nothing found" on five of six dimensions: we would have shipped a schema whose output our own
+ * gate accused of having no product judgment. That is the false-accusation failure the whole
+ * unconfirmed-not-absent program exists to remove, so it must not be reintroduced by two of our
+ * own tools disagreeing about where judgment lives.
+ *
+ * THE PRECEDENCE RULES, and each one is a decision rather than a default:
+ *
+ *  1. A recognized change-local `intent.md` is AUTHORITATIVE for the product fields. It was
+ *     written to answer exactly these questions, in a format built for them.
+ *  2. No `intent.md` -> fall back to `openSpecChangeToSpec()` unchanged, so a standard OpenSpec
+ *     repo grades exactly as it did before this file existed. Pinned by test.
+ *  3. An `intent.md` that exists but cannot be read is an ERROR, never a silent fallback. Quietly
+ *     grading proposal.md instead would report a verdict about a document the author did not
+ *     write, and hide the broken file that caused it.
+ *  4. Blank fields are NEVER backfilled from proposal.md. A missing objective in an intent.md is
+ *     an unfinished product judgment, and the gate saying so is the product working. Merging the
+ *     proposal's `## Why` over the gap would manufacture a pass out of a document written to
+ *     answer a different question.
+ *
+ * Read-only throughout: nothing here writes, moves, or creates a file.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CHANGE_LOCAL_INTENT_FILE = void 0;
+exports.isProductReadError = isProductReadError;
+exports.readOpenSpecChangeForPathmode = readOpenSpecChangeForPathmode;
+const fs_1 = __importDefault(__nccwpck_require__(9896));
+const path_1 = __importDefault(__nccwpck_require__(6928));
+const openspec_reader_1 = __nccwpck_require__(7290);
+const local_reader_1 = __nccwpck_require__(8963);
+/** The file the `pathmode-intent` schema's `product-intent` artifact generates. */
+exports.CHANGE_LOCAL_INTENT_FILE = 'intent.md';
+function isProductReadError(r) {
+    return r.error !== undefined;
+}
+/**
+ * Does a verification object hold anything?
+ *
+ * A deliberately tiny local predicate rather than `toVerificationChecks` from the intent
+ * compiler: importing that pulled roughly a thousand generated lines of the compiler into the
+ * published CLI bundle, and nothing here needs to normalize checks. The verification object
+ * travels verbatim, so all this has to answer is "is there content".
+ */
+function hasVerificationContent(v) {
+    if (!v || typeof v !== 'object')
+        return false;
+    const src = v;
+    return Boolean(src.checks?.length || src.manualChecks?.length || src.unitTests?.length || src.e2eTests?.length);
+}
+/**
+ * Does this parse carry any product judgment at all?
+ *
+ * Title alone does not count: `parseIntentMarkdown` defaults it to 'Untitled Intent', so a file
+ * of pure comments would otherwise read as "recognized" and grade as five empty gates.
+ */
+function carriesJudgment(intent) {
+    return Boolean((intent.objective || '').trim() ||
+        (intent.outcomes || []).length ||
+        (intent.constraints || []).length ||
+        (intent.edgeCases || []).length ||
+        hasVerificationContent(intent.verification));
+}
+/** Project a parsed intent.md onto the six-gate shape, keeping what makes it an intent.md. */
+function intentToProjection(intent) {
+    const spec = {
+        // The title is taken as written, with NO fallback to the change-directory name. An
+        // earlier version substituted the directory name whenever it saw the 'Untitled Intent'
+        // placeholder, which quietly handed a passing title gate to a scaffold nobody had filled
+        // in: the directory is always named something, so the gate could never report an
+        // unnamed change. `parseIntentMarkdown` already defaults a title-less file to 'Untitled
+        // Intent', and the gate knows that string is a placeholder, so passing it through is
+        // what makes an unfinished file read as unfinished.
+        title: intent.title || '',
+        objective: (intent.objective || '').trim(),
+        outcomes: (intent.outcomes || []).map(o => (typeof o === 'string' ? o : String(o?.text ?? ''))).filter(Boolean),
+        constraints: (intent.constraints || []).map(c => (typeof c === 'string' ? c : String(c ?? ''))).filter(Boolean),
+        edgeCases: (intent.edgeCases || [])
+            .map(ec => ({ scenario: String(ec?.scenario ?? '').trim(), expectedBehavior: String(ec?.expectedBehavior ?? '').trim() }))
+            .filter(ec => ec.scenario || ec.expectedBehavior),
+        // Verbatim: kinds are semantics, not decoration.
+        verification: intent.verification ?? {},
+        hasContent: true,
+    };
+    // Only set the key when the file actually carried one, so a spec with no Confirmations
+    // section is indistinguishable from one that never had the concept.
+    if (intent.confirmations?.length)
+        spec.confirmations = intent.confirmations;
+    return spec;
+}
+/**
+ * Read a change's product judgment, preferring a change-local intent.md.
+ *
+ * `readFile` is injectable so tests can simulate an unreadable file (a permissions error, a
+ * directory where a file belongs) without depending on the filesystem to misbehave on cue.
+ */
+function readOpenSpecChangeForPathmode(ref, io = {}) {
+    const exists = io.exists ?? ((p) => { try {
+        return fs_1.default.existsSync(p);
+    }
+    catch {
+        return false;
+    } });
+    const readFile = io.readFile ?? ((p) => fs_1.default.readFileSync(p, 'utf-8'));
+    const intentPath = path_1.default.join(ref.dir, exports.CHANGE_LOCAL_INTENT_FILE);
+    if (!exists(intentPath)) {
+        // Rule 2: a standard OpenSpec repo is graded exactly as before.
+        return { spec: (0, openspec_reader_1.openSpecChangeToSpec)(ref), source: 'openspec-artifacts', notes: [] };
+    }
+    let raw;
+    try {
+        raw = readFile(intentPath);
+    }
+    catch (e) {
+        // Rule 3. Name the file and the reason; do not grade something else instead.
+        return { error: `Found ${exports.CHANGE_LOCAL_INTENT_FILE} in this change but could not read it: ${e instanceof Error ? e.message : String(e)}`, intentPath };
+    }
+    let intent;
+    try {
+        intent = (0, local_reader_1.parseIntentMarkdown)(raw, ref.id);
+    }
+    catch (e) {
+        // gray-matter throws on malformed frontmatter. Same rule: an explicit failure beats a
+        // verdict about a different document.
+        return { error: `Found ${exports.CHANGE_LOCAL_INTENT_FILE} in this change but could not parse it: ${e instanceof Error ? e.message : String(e)}`, intentPath };
+    }
+    if (!carriesJudgment(intent)) {
+        return {
+            error: `Found ${exports.CHANGE_LOCAL_INTENT_FILE} in this change but read no product judgment from it. Expected at least one of ## Objective, ## Outcomes, ## Constraints, ## Edge Cases, or ## Verification. Renaming a heading makes its section invisible.`,
+            intentPath,
+        };
+    }
+    const notes = [
+        `Product judgment read from ${exports.CHANGE_LOCAL_INTENT_FILE}; proposal.md, design.md, spec deltas, and tasks.md were not merged into these fields.`,
+    ];
+    // Rule 4, said out loud rather than inferred from an empty verdict line.
+    const blank = [
+        !(intent.objective || '').trim() && 'objective',
+        !(intent.outcomes || []).length && 'outcomes',
+        !(intent.constraints || []).length && 'constraints',
+        !(intent.edgeCases || []).length && 'edge cases',
+        !hasVerificationContent(intent.verification) && 'verification',
+    ].filter(Boolean);
+    if (blank.length) {
+        notes.push(`${exports.CHANGE_LOCAL_INTENT_FILE} left ${blank.join(', ')} empty. These are reported as missing rather than filled in from proposal.md, because an unfinished product judgment is the thing worth seeing.`);
+    }
+    return { spec: intentToProjection(intent), source: 'intent.md', intentPath, notes };
+}
+
+
 /***/ }),
 
 /***/ 2804:
@@ -24428,6 +24637,14 @@ module.exports = /*#__PURE__*/JSON.parse('{"$id":"https://raw.githubusercontent.
 "use strict";
 module.exports = /*#__PURE__*/JSON.parse('{"$schema":"http://json-schema.org/draft-07/schema#","$id":"http://json-schema.org/draft-07/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"$comment":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":true,"readOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":true},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":true,"enum":{"type":"array","items":true,"minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"if":{"$ref":"#"},"then":{"$ref":"#"},"else":{"$ref":"#"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":true}');
 
+/***/ }),
+
+/***/ 8330:
+/***/ ((module) => {
+
+"use strict";
+module.exports = {"rE":"2.1.3"};
+
 /***/ })
 
 /******/ 	});

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@pathmode/cli",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "publishConfig": {
     "access": "public"
   },
-  "description": "The Intent Layer CLI \u2014 Spec-Driven Development with Pathmode",
+  "description": "The Intent Layer CLI — Spec-Driven Development with Pathmode",
   "main": "dist/index.js",
   "bin": {
     "pathmode": "dist/index.js"