peaks-cli 1.1.1 → 1.1.2

package/dist/src/cli/commands/request-commands.js

@@ -126,6 +126,18 @@ export function registerRequestCommands(program, io) {
         try {
             const role = options.role;
             const newState = parseStateForRole(role, options.state);
+            // Resolve the artifact's real session up front. Falling back to a literal
+            // 'default' (the previous behavior) points the bypass counter at a
+            // non-existent .peaks/default/ dir and crashes with ENOENT, so when
+            // --session-id is omitted we look the artifact up to find its session.
+            let resolvedSessionId = options.sessionId;
+            if (resolvedSessionId === undefined) {
+                const { showRequestArtifact: showForSession } = await import('../../services/artifacts/request-artifact-service.js');
+                const located = await showForSession({ projectRoot: options.project, role, requestId });
+                if (located !== null) {
+                    resolvedSessionId = located.sessionId;
+                }
+            }
             if (options.allowIncomplete === true && (options.reason === undefined || options.reason.trim().length === 0)) {
                 printResult(io, fail('request.transition', 'BYPASS_REASON_REQUIRED', '--allow-incomplete requires --reason explaining why prerequisites are skipped', { role, requestId }, ['Add --reason "<short justification>" or remove --allow-incomplete and produce the missing artifacts']), options.json);
                 process.exitCode = 1;
@@ -142,7 +154,7 @@ export function registerRequestCommands(program, io) {
                         return;
                     }
                     // Check bypass count
-                    const sessionRoot = (await import('node:path')).join(options.project, '.peaks', options.sessionId ?? 'default');
+                    const sessionRoot = (await import('node:path')).join(options.project, '.peaks', resolvedSessionId ?? 'default');
                     if (isBypassLimitReached(sessionRoot)) {
                         printResult(io, fail('request.transition', 'BYPASS_LIMIT_REACHED', `--allow-incomplete limit reached (${MAX_BYPASSES_PER_SESSION} per session)`, { role, requestId, limit: MAX_BYPASSES_PER_SESSION }, ['Produce the missing artifacts instead of bypassing.']), options.json);
                         process.exitCode = 1;

package/dist/src/services/artifacts/artifact-lint-service.js

@@ -35,6 +35,15 @@ const ALLOWLIST_PATTERNS = [
 function isAllowlisted(line) {
     return ALLOWLIST_PATTERNS.some((pattern) => pattern.test(line));
 }
+/**
+ * Remove inline code spans (`...`) before applying placeholder rules. Content
+ * inside backticks is literal example text — e.g. a documented command syntax
+ * `peaks sop init <id>` — not an unfilled prose placeholder. Lint checks prose,
+ * not code, so a `<...>` token only counts when it appears outside code spans.
+ */
+function stripInlineCode(line) {
+    return line.replace(/`[^`]*`/g, '');
+}
 export async function lintRequestArtifact(options) {
     const showOptions = {
         projectRoot: options.projectRoot,
@@ -50,14 +59,24 @@ export async function lintRequestArtifact(options) {
     }
     const lines = artifact.content.split(/\r?\n/);
     const findings = [];
+    let insideFence = false;
     for (let index = 0; index < lines.length; index += 1) {
         const rawLine = lines[index];
         if (rawLine === undefined)
             continue;
+        // Fenced code blocks hold literal examples, not prose to fill; skip their
+        // contents entirely (the fence delimiters themselves toggle the state).
+        if (/^\s*```/.test(rawLine)) {
+            insideFence = !insideFence;
+            continue;
+        }
+        if (insideFence)
+            continue;
         if (isAllowlisted(rawLine))
             continue;
+        const testLine = stripInlineCode(rawLine);
         for (const rule of RULES) {
-            if (rule.test(rawLine)) {
+            if (rule.test(testLine)) {
                 findings.push({
                     line: index + 1,
                     text: rawLine.trim(),

package/dist/src/services/artifacts/artifact-prerequisites.js

@@ -1,5 +1,5 @@
-import { join } from 'node:path';
-import { readFile } from 'node:fs/promises';
+import { join, dirname, basename } from 'node:path';
+import { readFile, readdir } from 'node:fs/promises';
 import { pathExists } from '../../shared/fs.js';
 export const VALID_REQUEST_TYPES = [
     'feature',
@@ -111,6 +111,36 @@ export function getPrerequisitesFor(role, newState, requestType = DEFAULT_REQUES
 function resolvePrerequisitePath(prerequisite, requestId) {
     return prerequisite.relativePath.replace('<rid>', requestId);
 }
+/**
+ * Resolve a prerequisite to an on-disk path, tolerating the numbered filename
+ * prefix that `request init` writes (e.g. `001-<rid>.md`). When the prerequisite
+ * path contains `<rid>`, we accept either the legacy bare `<rid>.md` form or any
+ * `NNN-<rid>.md` numbered form — mirroring the matcher in request-artifact-service.
+ * Returns the matched absolute path, or null when nothing matches.
+ */
+async function resolvePrerequisiteAbsolutePath(sessionRoot, prerequisite, requestId) {
+    const relative = resolvePrerequisitePath(prerequisite, requestId);
+    const exact = join(sessionRoot, relative);
+    if (await pathExists(exact)) {
+        return exact;
+    }
+    // Only `<rid>`-templated prerequisites can carry a numbered prefix; fixed paths
+    // (e.g. rd/tech-doc.md) are matched exactly above.
+    if (!prerequisite.relativePath.includes('<rid>')) {
+        return null;
+    }
+    const dir = dirname(exact);
+    const targetSuffix = `-${basename(exact)}`;
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return null;
+    }
+    const match = entries.find((name) => /^\d+-/.test(name) && name.endsWith(targetSuffix));
+    return match ? join(dir, match) : null;
+}
 export async function checkPrerequisites(options) {
     const requirements = getPrerequisitesFor(options.role, options.newState, options.requestType);
     if (requirements.length === 0) {
@@ -120,8 +150,8 @@ export async function checkPrerequisites(options) {
     const missing = [];
     for (const prerequisite of requirements) {
         const relative = resolvePrerequisitePath(prerequisite, options.requestId);
-        const absolute = join(sessionRoot, relative);
-        if (!(await pathExists(absolute))) {
+        const absolute = await resolvePrerequisiteAbsolutePath(sessionRoot, prerequisite, options.requestId);
+        if (absolute === null) {
             missing.push({ path: relative, description: prerequisite.description });
             continue;
         }

package/dist/src/services/scan/type-sanity-service.js

@@ -25,6 +25,16 @@ function classifyFile(filePath) {
         return 'source';
     return 'unknown';
 }
+/**
+ * Peaks' own artifact workspace. Changes here (PRD/RD/QA markdown, session
+ * state) are never the "code change" a request type describes, so they must be
+ * excluded from the diff — otherwise a PRD-planning-phase handoff that only
+ * wrote `.peaks/**` markdown would be misclassified as a docs change.
+ */
+function isArtifactWorkspaceFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    return normalized === '.peaks' || normalized.startsWith('.peaks/');
+}
 function tryGitDiffFiles(projectRoot, baseRef) {
     try {
         // Combine: tracked changes vs baseRef + untracked files. Use porcelain status for untracked too.
@@ -32,7 +42,7 @@ function tryGitDiffFiles(projectRoot, baseRef) {
         const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
         const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8' });
         const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-        const merged = Array.from(new Set([...tracked, ...untracked]));
+        const merged = Array.from(new Set([...tracked, ...untracked])).filter((file) => !isArtifactWorkspaceFile(file));
         return { ok: true, files: merged };
     }
     catch {

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "1.1.1";
+export declare const CLI_VERSION = "1.1.2";

package/dist/src/shared/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "1.1.1";
+export const CLI_VERSION = "1.1.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-cli",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Peaks CLI and short skill family for Claude Code automation.",
   "author": "SquabbyZ",
   "license": "MIT",