@fission-ai/openspec 1.8.0 → 1.10.0

package/dist/utils/interactive.js

@@ -1,3 +1,4 @@
+import { createInterface } from 'node:readline';
 /**
  * Resolves whether non-interactive mode is requested.
  * Handles both explicit `noInteractive: true` and Commander.js style `interactive: false`.
@@ -38,7 +39,12 @@ export function isInteractive(value) {
  *   somebody was there and chose to quit.
  *
  * Beyond that it defers to `isInteractive()`, so `CI`, `OPEN_SPEC_INTERACTIVE=0`
- * and `--no-interactive` count even when a runner allocated a pty.
+ * and `--no-interactive` count even when a runner allocated a pty. It also
+ * counts a redirected stdout: `confirmPrompt` drops to the plain reader whenever
+ * *either* stream is not a TTY, so a stdin-TTY-but-stdout-redirected run
+ * (`openspec archive x > log.txt` from a terminal) that hits EOF must classify
+ * the same way the prompt was selected — otherwise it would leak the raw
+ * `ExitPromptError` instead of the `--yes` guidance.
  */
 export function isNonInteractivePromptError(error, value) {
     if (!(error instanceof Error))
@@ -48,6 +54,103 @@ export function isNonInteractivePromptError(error, value) {
         return false;
     if (error.message.includes('SIGINT'))
         return false;
-    return !isInteractive(value);
+    return !isInteractive(value) || !process.stdout.isTTY;
+}
+/**
+ * Ask a yes/no question. A real terminal gets @inquirer's rich prompt;
+ * everything else — a pipe, a file redirect, an agent that captures stdout —
+ * reads one plain line instead.
+ *
+ * @inquirer renders `confirm` by writing ANSI cursor-movement escape sequences,
+ * and it emits them even when stdout is not a TTY. Redirected to a file those
+ * sequences are noise, and in some non-TTY hosts the render loop never settles
+ * and repeats `ESC[NNG` cursor moves until the disk fills (#1526). Reading
+ * the answer ourselves keeps the single piped answer @inquirer ever supported
+ * working (`printf 'y\n' | openspec archive ...`) without emitting any escapes.
+ *
+ * `io` overrides the streams; it exists for tests and mirrors @inquirer's own
+ * `{ input, output }` context. Production callers pass only the prompt.
+ */
+export async function confirmPrompt(prompt, io = {}) {
+    const input = io.input ?? process.stdin;
+    const output = io.output ?? process.stdout;
+    const isTerminal = Boolean(input.isTTY) &&
+        Boolean(output.isTTY);
+    if (isTerminal) {
+        const { confirm } = await import('@inquirer/prompts');
+        return confirm(prompt);
+    }
+    return readYesNo(prompt, input, output);
+}
+function readYesNo(prompt, input, output) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        // Detach the input-stream error listener on settle: `input` is the
+        // long-lived process.stdin, so a leftover listener would accumulate across
+        // archive's successive prompts and swallow a later, unrelated stdin error.
+        const cleanup = () => {
+            input.removeListener('error', onError);
+        };
+        const blockOnNoAnswer = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            // No line could be read (stdin closed / EOF). Mirror @inquirer's failure
+            // so callers that classify it — isNonInteractivePromptError, the #1479
+            // "rerun with --yes" guidance — keep working unchanged.
+            const error = new Error('User force closed the prompt');
+            error.name = 'ExitPromptError';
+            reject(error);
+        };
+        // A stdin error surfaces on the interface (readline forwards input-stream
+        // errors since Node 16). Without a handler the promise would hang and the
+        // 'error' would go unhandled; settle it with the real fault instead.
+        const onError = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            rl.close();
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        // An earlier prompt may have already drained stdin (only one piped answer
+        // was ever supported). A fresh readline over an ended stream never emits
+        // 'close', so guard here rather than hang and exit as a no-op.
+        if (input.readableEnded) {
+            blockOnNoAnswer();
+            return;
+        }
+        output.write(`${prompt.message} ${prompt.default ? '(Y/n)' : '(y/N)'} `);
+        // terminal:false guarantees readline never emits its own line-editing
+        // escapes — an escape-free read is the whole point here.
+        const rl = createInterface({ input, terminal: false });
+        input.once('error', onError);
+        rl.once('error', onError);
+        rl.once('line', (line) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            rl.close();
+            output.write('\n');
+            // Mirror @inquirer/confirm's parser (prefix match on y/yes and n/no,
+            // otherwise the default) so a piped answer resolves identically to the
+            // interactive prompt it replaces.
+            const answer = line.trim();
+            if (/^(y|yes)/i.test(answer)) {
+                resolve(true);
+            }
+            else if (/^(n|no)/i.test(answer)) {
+                resolve(false);
+            }
+            else {
+                resolve(prompt.default);
+            }
+        });
+        rl.once('close', () => {
+            blockOnNoAnswer();
+        });
+    });
 }
 //# sourceMappingURL=interactive.js.map

package/dist/utils/task-progress.d.ts

@@ -20,6 +20,27 @@ export interface TaskProgress {
     completed: number;
 }
 export declare function countTasksFromContent(content: string): TaskProgress;
+/**
+ * Run-scoped memo mapping a schema name to its tracked-tasks `generates` glob.
+ * When one command resolves progress for many changes under a constant
+ * `projectRoot` — e.g. `validate --archived` over an append-only archive — this
+ * avoids re-reading and re-parsing (YAML + Zod) the same `schema.yaml` once per
+ * change. Keyed by schema name alone, which is safe *only* because a single run
+ * holds `projectRoot` constant; never reuse one cache across differing roots.
+ */
+export type SchemaGlobCache = Map<string, string | undefined>;
+/** Resolves the task files selected by the schema's apply tracking rule. */
+export declare function resolveTaskFilesForChange(changeDir: string, projectRoot: string, schemaGlobCache?: SchemaGlobCache): string[];
+export interface TaskProgressDetail extends TaskProgress {
+    /**
+     * Task files that exist but could not be read (any error other than ENOENT).
+     * `getTaskProgressForChange` discards this list to preserve its behavior;
+     * callers that must fail loudly on an unreadable tasks file — e.g.
+     * `openspec validate --archived` — read it so an unreadable file is never
+     * silently counted as "no tasks" (#205).
+     */
+    unreadable: string[];
+}
 /**
  * Computes a change's task progress by resolving its tracked-tasks artifact and
  * counting checkboxes across every file matched by that artifact's `generates`
@@ -27,7 +48,19 @@ export declare function countTasksFromContent(content: string): TaskProgress;
  * artifact (`resolveArtifactOutputs`) — so progress is no longer blind to nested
  * `tasks.md` files (#1202). Falls back to a single top-level `tasks.md` (exactly
  * as before) when the schema is unresolvable, no tracked-tasks artifact is found,
- * or the glob matches no file. Never throws.
+ * or the glob matches no file. Also reports task files that exist but could not
+ * be read. Per-file read errors are captured (never thrown); the only throw path
+ * is a malformed/unsafe schema whose glob resolution rejects (path traversal or
+ * a linked-directory cycle in `resolveArtifactOutputs`). Pass `schemaGlobCache`
+ * to memoize schema→glob resolution across many changes in one run.
+ */
+export declare function getTaskProgressDetailForChange(changesDir: string, changeName: string, projectRoot: string, schemaGlobCache?: SchemaGlobCache): Promise<TaskProgressDetail>;
+/**
+ * The task-completion counter `status`, `list`, and `archive` share. Delegates
+ * to `getTaskProgressDetailForChange` and drops the `unreadable` detail, so its
+ * returned totals are unchanged. Throws only on the same malformed/unsafe-schema
+ * glob-resolution path as that function (existing behavior; callers guard it as
+ * they did before).
  */
 export declare function getTaskProgressForChange(changesDir: string, changeName: string, projectRoot: string): Promise<TaskProgress>;
 export declare function formatTaskStatus(progress: TaskProgress): string;

package/dist/utils/task-progress.js

@@ -64,24 +64,43 @@ function findTrackedTasksArtifact(schema) {
  * when the schema cannot be resolved or no tracked-tasks artifact exists.
  * `resolveSchema` throws on an unresolvable/misnamed schema; we swallow that so
  * the caller falls back to a single top-level `tasks.md` and never crashes.
+ * A `schemaGlobCache`, when supplied, memoizes the schema-name → glob lookup for
+ * the duration of one run.
  */
-function resolveTrackedTasksGlob(changeDir, projectRoot) {
+function resolveTrackedTasksGlob(changeDir, projectRoot, schemaGlobCache) {
     try {
         const schemaName = resolveSchemaForChange(changeDir, undefined, projectRoot);
+        if (schemaGlobCache?.has(schemaName))
+            return schemaGlobCache.get(schemaName);
         const schema = resolveSchema(schemaName, projectRoot);
-        return findTrackedTasksArtifact(schema)?.generates;
+        const generates = findTrackedTasksArtifact(schema)?.generates;
+        schemaGlobCache?.set(schemaName, generates);
+        return generates;
     }
     catch {
         return undefined;
     }
 }
-async function countSingleTopLevelTasksFile(changeDir) {
-    const tasksPath = path.join(changeDir, 'tasks.md');
+/** Resolves the task files selected by the schema's apply tracking rule. */
+export function resolveTaskFilesForChange(changeDir, projectRoot, schemaGlobCache) {
+    const generates = resolveTrackedTasksGlob(changeDir, projectRoot, schemaGlobCache);
+    return generates ? resolveArtifactOutputs(changeDir, generates) : [];
+}
+/**
+ * Reads one task file and counts its checkboxes. ENOENT (a glob file that
+ * vanished between resolve and read, or the absent single top-level `tasks.md`)
+ * means zero tasks, exactly as before. Any other error (permissions, I/O,
+ * ENOTDIR) is recorded in `unreadable` so a caller can surface it; the count
+ * still contributes zero, so existing callers see no change.
+ */
+async function countTaskFile(file, unreadable) {
     try {
-        const content = await fs.readFile(tasksPath, 'utf-8');
+        const content = await fs.readFile(file, 'utf-8');
         return countTasksFromContent(content);
     }
-    catch {
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            unreadable.push(file);
         return { total: 0, completed: 0 };
     }
 }
@@ -92,31 +111,36 @@ async function countSingleTopLevelTasksFile(changeDir) {
  * artifact (`resolveArtifactOutputs`) — so progress is no longer blind to nested
  * `tasks.md` files (#1202). Falls back to a single top-level `tasks.md` (exactly
  * as before) when the schema is unresolvable, no tracked-tasks artifact is found,
- * or the glob matches no file. Never throws.
+ * or the glob matches no file. Also reports task files that exist but could not
+ * be read. Per-file read errors are captured (never thrown); the only throw path
+ * is a malformed/unsafe schema whose glob resolution rejects (path traversal or
+ * a linked-directory cycle in `resolveArtifactOutputs`). Pass `schemaGlobCache`
+ * to memoize schema→glob resolution across many changes in one run.
  */
-export async function getTaskProgressForChange(changesDir, changeName, projectRoot) {
+export async function getTaskProgressDetailForChange(changesDir, changeName, projectRoot, schemaGlobCache) {
     const changeDir = path.join(changesDir, changeName);
-    const generates = resolveTrackedTasksGlob(changeDir, projectRoot);
-    if (generates) {
-        const files = resolveArtifactOutputs(changeDir, generates);
-        if (files.length > 0) {
-            let total = 0;
-            let completed = 0;
-            for (const file of files) {
-                try {
-                    const content = await fs.readFile(file, 'utf-8');
-                    const progress = countTasksFromContent(content);
-                    total += progress.total;
-                    completed += progress.completed;
-                }
-                catch {
-                    // Swallow files that vanish between glob and read, as before.
-                }
-            }
-            return { total, completed };
-        }
+    const files = resolveTaskFilesForChange(changeDir, projectRoot, schemaGlobCache);
+    const targets = files.length > 0 ? files : [path.join(changeDir, 'tasks.md')];
+    const unreadable = [];
+    let total = 0;
+    let completed = 0;
+    for (const file of targets) {
+        const progress = await countTaskFile(file, unreadable);
+        total += progress.total;
+        completed += progress.completed;
     }
-    return countSingleTopLevelTasksFile(changeDir);
+    return { total, completed, unreadable };
+}
+/**
+ * The task-completion counter `status`, `list`, and `archive` share. Delegates
+ * to `getTaskProgressDetailForChange` and drops the `unreadable` detail, so its
+ * returned totals are unchanged. Throws only on the same malformed/unsafe-schema
+ * glob-resolution path as that function (existing behavior; callers guard it as
+ * they did before).
+ */
+export async function getTaskProgressForChange(changesDir, changeName, projectRoot) {
+    const { total, completed } = await getTaskProgressDetailForChange(changesDir, changeName, projectRoot);
+    return { total, completed };
 }
 export function formatTaskStatus(progress) {
     if (progress.total === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fission-ai/openspec",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "openspec",
@@ -33,7 +33,6 @@
     "dist",
     "bin",
     "schemas",
-    "scripts/postinstall.js",
     "!dist/**/*.test.js",
     "!dist/**/__tests__",
     "!dist/**/*.map"
@@ -53,8 +52,8 @@
     "vitest": "^3.2.6"
   },
   "dependencies": {
-    "@inquirer/core": "^10.3.2",
-    "@inquirer/prompts": "^7.10.1",
+    "@inquirer/core": "^11.2.1",
+    "@inquirer/prompts": "^8.5.2",
     "chalk": "^5.6.2",
     "commander": "^14.0.0",
     "cross-spawn": "7.0.6",
@@ -74,8 +73,6 @@
     "test:watch": "vitest",
     "test:ui": "vitest --ui",
     "test:coverage": "vitest --coverage",
-    "test:postinstall": "node scripts/postinstall.js",
-    "postinstall": "node scripts/postinstall.js",
     "check:pack-version": "node scripts/pack-version-check.mjs",
     "release": "pnpm run release:ci",
     "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",

package/schemas/spec-driven/schema.yaml

@@ -91,10 +91,16 @@ artifacts:
       by hand. Do NOT add `## Purpose` to a delta for an existing capability -
       that spec already has one and the delta's is ignored. To change an
       existing capability's Purpose - including a leftover `TBD` placeholder -
-      edit `openspec/specs/<capability-path>/spec.md` directly.
+      edit `<planningHome.root>/openspec/specs/<capability-path>/spec.md`
+      directly. `planningHome.root` comes from the `openspec instructions ...
+      --json` response. Always use it rather than a repo-relative path: it
+      resolves to the store whenever the change lives in one - whether that
+      came from `--store`, a project `store:` pointer, or a global default
+      store - and to the current repository otherwise. Do not try to work out
+      which case applies; the field already has.
 
       MODIFIED requirements workflow:
-      1. Locate the existing requirement in openspec/specs/<capability-path>/spec.md
+      1. Locate the existing requirement in `<planningHome.root>/openspec/specs/<capability-path>/spec.md` (the same store-aware root as above)
       2. Copy the ENTIRE requirement block (from `### Requirement:` through all scenarios)
       3. Paste under `## MODIFIED Requirements` and edit to reflect new behavior
       4. Ensure header text matches exactly (whitespace-insensitive)
@@ -182,22 +188,26 @@ artifacts:
       - Each task MUST be a checkbox: `- [ ] X.Y Task description`
       - Tasks should be small enough to complete in one session
       - Order tasks by dependency (what must be done first?)
+      - Each task MUST state how to verify completion (a test, command,
+        observable behavior, or delivered artifact). Put the verification in
+        that task's checkbox description. Use a separate verification task only
+        when it checks broader integration or system behavior that spans
+        multiple implementation tasks.
 
       Example:
       ```
       ## 1. Setup
 
-      - [ ] 1.1 Create new module structure
-      - [ ] 1.2 Add dependencies to package.json
+      - [ ] 1.1 Create new module structure and verify expected files are present
+      - [ ] 1.2 Add dependencies to package.json and verify package installation succeeds
 
       ## 2. Core Implementation
 
-      - [ ] 2.1 Implement data export function
-      - [ ] 2.2 Add CSV formatting utilities
+      - [ ] 2.1 Implement data export function and verify the export test passes
+      - [ ] 2.2 Add CSV formatting utilities and verify unit tests cover quoting and delimiters
       ```
 
       Reference specs for what needs to be built, design for how to build it.
-      Each task should be verifiable - you know when it's done.
     requires:
       - specs
       - design

package/scripts/postinstall.js

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Postinstall script that hints about shell completions
- *
- * Completion installation is opt-in: the user must run
- * `openspec completion install` explicitly. This script only
- * prints a one-line tip after npm install.
- *
- * The tip is suppressed when:
- * - CI=true environment variable is set
- * - OPENSPEC_NO_COMPLETIONS=1 environment variable is set
- * - dist/ directory doesn't exist (dev setup scenario)
- *
- * The script never fails npm install - all errors are caught and handled gracefully.
- */
-
-import { promises as fs } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * Check if we should skip installation
- */
-function shouldSkipInstallation() {
-  // Skip in CI environments
-  if (process.env.CI === 'true' || process.env.CI === '1') {
-    return { skip: true, reason: 'CI environment detected' };
-  }
-
-  // Skip if user opted out
-  if (process.env.OPENSPEC_NO_COMPLETIONS === '1') {
-    return { skip: true, reason: 'OPENSPEC_NO_COMPLETIONS=1 set' };
-  }
-
-  return { skip: false };
-}
-
-/**
- * Check if dist/ directory exists
- */
-async function distExists() {
-  const distPath = path.join(__dirname, '..', 'dist');
-  try {
-    const stat = await fs.stat(distPath);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Main function
- */
-async function main() {
-  try {
-    // Check if we should skip
-    const skipCheck = shouldSkipInstallation();
-    if (skipCheck.skip) {
-      // Silent skip - no output
-      return;
-    }
-
-    // Check if dist/ exists (skip silently if not - expected during dev setup)
-    if (!(await distExists())) {
-      return;
-    }
-
-    // Completions are opt-in — just print a hint
-    console.log(`\nTip: Run 'openspec completion install' for shell completions`);
-  } catch (error) {
-    // Fail gracefully - never break npm install
-  }
-}
-
-// Run main and handle any unhandled errors
-main().catch(() => {
-  // Silent failure - never break npm install
-  process.exit(0);
-});