@codewalla_india/openspec 1.3.1 → 1.3.2

package/dist/utils/item-discovery.js

@@ -1,23 +1,25 @@
 import { promises as fs } from 'fs';
 import path from 'path';
+import { discoverSpecFiles } from './spec-discovery.js';
+/**
+ * Returns the ids of active changes: every directory under openspec/changes/
+ * except the archive and hidden directories.
+ *
+ * A change is resolved by its directory alone - the same rule `list`,
+ * `status`, `instructions` and `validate` use (`getAvailableChanges`).
+ * Requiring proposal.md here made `openspec show` and shell completion miss
+ * changes those commands resolve: `openspec new change <name>` scaffolds only
+ * `.openspec.yaml`, and a custom schema need not define a proposal artifact at
+ * all (#1161).
+ */
 export async function getActiveChangeIds(root = process.cwd()) {
     const changesPath = path.join(root, 'openspec', 'changes');
     try {
         const entries = await fs.readdir(changesPath, { withFileTypes: true });
-        const result = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'archive')
-                continue;
-            const proposalPath = path.join(changesPath, entry.name, 'proposal.md');
-            try {
-                await fs.access(proposalPath);
-                result.push(entry.name);
-            }
-            catch {
-                // skip directories without proposal.md
-            }
-        }
-        return result.sort();
+        return entries
+            .filter((entry) => entry.isDirectory() && entry.name !== 'archive' && !entry.name.startsWith('.'))
+            .map((entry) => entry.name)
+            .sort();
     }
     catch {
         return [];
@@ -25,45 +27,25 @@ export async function getActiveChangeIds(root = process.cwd()) {
 }
 export async function getSpecIds(root = process.cwd()) {
     const specsPath = path.join(root, 'openspec', 'specs');
-    const result = [];
-    try {
-        const entries = await fs.readdir(specsPath, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith('.'))
-                continue;
-            const specFile = path.join(specsPath, entry.name, 'spec.md');
-            try {
-                await fs.access(specFile);
-                result.push(entry.name);
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    catch {
-        // ignore
-    }
-    return result.sort();
+    const discovered = await discoverSpecFiles(specsPath);
+    return discovered.map((spec) => spec.id);
 }
+/**
+ * Returns the ids of archived changes: every directory under
+ * openspec/changes/archive/ except hidden directories.
+ *
+ * Resolved by directory for the same reason as `getActiveChangeIds`: a change
+ * archived from a schema without a proposal artifact has no proposal.md, and
+ * gating on it hid those entries from shell completion.
+ */
 export async function getArchivedChangeIds(root = process.cwd()) {
     const archivePath = path.join(root, 'openspec', 'changes', 'archive');
     try {
         const entries = await fs.readdir(archivePath, { withFileTypes: true });
-        const result = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith('.'))
-                continue;
-            const proposalPath = path.join(archivePath, entry.name, 'proposal.md');
-            try {
-                await fs.access(proposalPath);
-                result.push(entry.name);
-            }
-            catch {
-                // skip directories without proposal.md
-            }
-        }
-        return result.sort();
+        return entries
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+            .map((entry) => entry.name)
+            .sort();
     }
     catch {
         return [];

package/dist/utils/shell-detection.d.ts

@@ -12,7 +12,7 @@ export interface ShellDetectionResult {
     detected: string | undefined;
 }
 /**
- * Detects the current user's shell based on environment variables
+ * Detects the current user's shell based on the parent process and environment
  *
  * @returns Detection result with supported shell and raw detected name
  */

package/dist/utils/shell-detection.js

@@ -1,21 +1,74 @@
+import { execFileSync } from 'node:child_process';
 /**
- * Detects the current user's shell based on environment variables
+ * Map a raw shell name/path to a supported shell, if any.
+ */
+function matchSupportedShell(name) {
+    // Match the executable basename exactly so lookalikes such as `fish-lsp` or
+    // `bash-language-server` don't get mistaken for the shell itself. Login
+    // shells report a leading dash (e.g. `-zsh`), so strip it first.
+    const executable = name.trim().toLowerCase().split('/').pop()?.replace(/^-/, '');
+    if (executable === 'zsh')
+        return 'zsh';
+    if (executable === 'bash')
+        return 'bash';
+    if (executable === 'fish')
+        return 'fish';
+    return undefined;
+}
+/**
+ * Detect the interactive shell from the parent process.
+ *
+ * `process.env.SHELL` is only the login shell, so users whose interactive shell
+ * differs from it (e.g. running fish while their login shell is bash) are
+ * misdetected. Inspecting the parent process reflects the shell that actually
+ * launched openspec. POSIX-only and best-effort — any failure returns undefined
+ * so the caller falls back to `$SHELL`.
+ *
+ * @returns The supported shell running as the parent process, or undefined
+ */
+function detectShellFromParentProcess() {
+    // `ps` is POSIX-only; Windows shells are handled via PSModulePath/COMSPEC.
+    if (process.platform === 'win32') {
+        return undefined;
+    }
+    const ppid = process.ppid;
+    if (!ppid || ppid <= 1) {
+        return undefined;
+    }
+    try {
+        const comm = execFileSync('ps', ['-p', String(ppid), '-o', 'comm='], {
+            encoding: 'utf8',
+            timeout: 1000,
+        }).trim();
+        if (!comm) {
+            return undefined;
+        }
+        // Only trust the parent process when it maps to a supported shell; an
+        // unrelated parent (node, npm, sudo, a pager) falls through to `$SHELL`.
+        return matchSupportedShell(comm);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Detects the current user's shell based on the parent process and environment
  *
  * @returns Detection result with supported shell and raw detected name
  */
 export function detectShell() {
-    // Try SHELL environment variable first (Unix-like systems)
+    // Prefer the actual running shell (parent process) over `$SHELL`, which only
+    // reflects the login shell and misses users whose interactive shell differs.
+    const parentShell = detectShellFromParentProcess();
+    if (parentShell) {
+        return { shell: parentShell, detected: parentShell };
+    }
+    // Try SHELL environment variable next (Unix-like systems)
     const shellPath = process.env.SHELL;
     if (shellPath) {
-        const shellName = shellPath.toLowerCase();
-        if (shellName.includes('zsh')) {
-            return { shell: 'zsh', detected: 'zsh' };
-        }
-        if (shellName.includes('bash')) {
-            return { shell: 'bash', detected: 'bash' };
-        }
-        if (shellName.includes('fish')) {
-            return { shell: 'fish', detected: 'fish' };
+        const supported = matchSupportedShell(shellPath);
+        if (supported) {
+            return { shell: supported, detected: supported };
         }
         // Shell detected but not supported
         // Extract shell name from path (e.g., /bin/tcsh -> tcsh)

package/dist/utils/spec-discovery.d.ts

@@ -0,0 +1,40 @@
+export interface DiscoveredSpec {
+    /** Spec id relative to the specs root, forward-slash separated on every platform (e.g. "web" or "platform/session-layout"). */
+    id: string;
+    /** Path to the spec.md file (absolute if the specs root is absolute). */
+    specFile: string;
+}
+/**
+ * Recursively discover every `spec.md` under a specs root, so both the flat
+ * `specs/<id>/spec.md` layout and nested `specs/<area>/<id>/spec.md` layouts
+ * are found (#1353). A `spec.md` sitting directly in the root is ignored,
+ * matching the historical requirement that specs live in a capability folder.
+ * Dot-directories are skipped and symlinked directories are not followed.
+ * An in-capability symlinked `spec.md` IS resolved: `hasAnyFileUnder` and the
+ * artifact graph's globs both count it as content, so dropping it here would
+ * silently lose the delta on archive. A link outside its capability is
+ * rejected and a dangling link is skipped. Results are sorted by id.
+ *
+ * A missing root (ENOENT) yields an empty list, but any other read failure
+ * (EACCES, EIO, ...) is thrown rather than swallowed: since this feeds the
+ * archive/apply merge path, silently dropping an unreadable capability would
+ * recreate the exact data-loss class #1353 is closing.
+ */
+export declare function discoverSpecFiles(specsRoot: string): Promise<DiscoveredSpec[]>;
+/**
+ * True when any regular non-dot file exists anywhere under the given
+ * directory. Used by validate/archive to detect content under a change's
+ * specs/ that contradicts a declared skip_specs marker - including files that
+ * discoverSpecFiles ignores (a root spec.md, stray non-spec.md notes), since
+ * anything there would be silently dropped or misread while the change claims
+ * to have nothing. Dot entries (.DS_Store, .gitkeep, dot-directories) are
+ * skipped to match discoverSpecFiles - they are invisible to every other
+ * code path, so they must not count as spec content. Symlinks DO count
+ * (without being followed): the artifact graph's globs follow them, so a
+ * symlinked spec would read as existing content while the change claims to
+ * have none - it contradicts the marker like any regular file. A missing
+ * directory returns false; other read failures are thrown for the caller to
+ * decide.
+ */
+export declare function hasAnyFileUnder(dirPath: string): Promise<boolean>;
+//# sourceMappingURL=spec-discovery.d.ts.map

package/dist/utils/spec-discovery.js

@@ -0,0 +1,115 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { FileSystemUtils } from './file-system.js';
+function assertDiscoveredSpecPath(specsRoot, capabilityDir, specFile) {
+    try {
+        FileSystemUtils.assertPathWithin(specsRoot, specFile);
+    }
+    catch {
+        // Direct capability directories may intentionally be external monorepo
+        // links. In that case, confine the file to the capability itself.
+        FileSystemUtils.assertPathWithin(capabilityDir, specFile);
+    }
+}
+/**
+ * Recursively discover every `spec.md` under a specs root, so both the flat
+ * `specs/<id>/spec.md` layout and nested `specs/<area>/<id>/spec.md` layouts
+ * are found (#1353). A `spec.md` sitting directly in the root is ignored,
+ * matching the historical requirement that specs live in a capability folder.
+ * Dot-directories are skipped and symlinked directories are not followed.
+ * An in-capability symlinked `spec.md` IS resolved: `hasAnyFileUnder` and the
+ * artifact graph's globs both count it as content, so dropping it here would
+ * silently lose the delta on archive. A link outside its capability is
+ * rejected and a dangling link is skipped. Results are sorted by id.
+ *
+ * A missing root (ENOENT) yields an empty list, but any other read failure
+ * (EACCES, EIO, ...) is thrown rather than swallowed: since this feeds the
+ * archive/apply merge path, silently dropping an unreadable capability would
+ * recreate the exact data-loss class #1353 is closing.
+ */
+export async function discoverSpecFiles(specsRoot) {
+    const results = [];
+    const walk = async (dir, segments) => {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch (err) {
+            if (err?.code === 'ENOENT')
+                return;
+            throw err;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.isDirectory()) {
+                await walk(path.join(dir, entry.name), [...segments, entry.name]);
+            }
+            else if (entry.name === 'spec.md' && segments.length > 0) {
+                const specFile = path.join(dir, entry.name);
+                if (entry.isFile()) {
+                    assertDiscoveredSpecPath(specsRoot, dir, specFile);
+                    results.push({ id: segments.join('/'), specFile });
+                }
+                else if (entry.isSymbolicLink()) {
+                    try {
+                        if ((await fs.stat(specFile)).isFile()) {
+                            assertDiscoveredSpecPath(specsRoot, dir, specFile);
+                            results.push({ id: segments.join('/'), specFile });
+                        }
+                    }
+                    catch (err) {
+                        // A dangling link is not content; anything else fails loudly.
+                        if (err?.code !== 'ENOENT')
+                            throw err;
+                    }
+                }
+            }
+        }
+    };
+    await walk(specsRoot, []);
+    // Plain code-point comparison, not localeCompare: the latter follows the
+    // process's ICU locale, so ordering could vary by OS/CI. Code-point ordering
+    // guarantees the deterministic output the docstring promises.
+    return results.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+/**
+ * True when any regular non-dot file exists anywhere under the given
+ * directory. Used by validate/archive to detect content under a change's
+ * specs/ that contradicts a declared skip_specs marker - including files that
+ * discoverSpecFiles ignores (a root spec.md, stray non-spec.md notes), since
+ * anything there would be silently dropped or misread while the change claims
+ * to have nothing. Dot entries (.DS_Store, .gitkeep, dot-directories) are
+ * skipped to match discoverSpecFiles - they are invisible to every other
+ * code path, so they must not count as spec content. Symlinks DO count
+ * (without being followed): the artifact graph's globs follow them, so a
+ * symlinked spec would read as existing content while the change claims to
+ * have none - it contradicts the marker like any regular file. A missing
+ * directory returns false; other read failures are thrown for the caller to
+ * decide.
+ */
+export async function hasAnyFileUnder(dirPath) {
+    let entries;
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT') {
+            return false;
+        }
+        throw err;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        if (entry.isFile() || entry.isSymbolicLink()) {
+            return true;
+        }
+        if (entry.isDirectory() && (await hasAnyFileUnder(path.join(dirPath, entry.name)))) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=spec-discovery.js.map

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

@@ -1,8 +1,36 @@
+export interface ParsedTask {
+    /** Checkbox state: `[x]`/`[X]` is done, anything else is not. */
+    done: boolean;
+    /** Task text after the checkbox, trimmed (may be empty). */
+    description: string;
+}
+/**
+ * Parses every task line in a tasks file, in document order.
+ *
+ * Every line matching the pattern counts, wherever it sits - inside a code
+ * fence, an HTML comment or an indented block, as before. Skipping fenced
+ * checkboxes was tried and dropped: every rule for deciding which fence is
+ * "real" has an input where a stray or unbalanced ``` swallows genuine tasks.
+ * Counting a documented example as work is a loud, bypassable false positive;
+ * losing a real task is a silent one.
+ */
+export declare function parseTaskLines(content: string): ParsedTask[];
 export interface TaskProgress {
     total: number;
     completed: number;
 }
 export declare function countTasksFromContent(content: string): TaskProgress;
-export declare function getTaskProgressForChange(changesDir: string, changeName: string): Promise<TaskProgress>;
+/** Resolves the task files selected by the schema's apply tracking rule. */
+export declare function resolveTaskFilesForChange(changeDir: string, projectRoot: string): 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`
+ * glob — the same file-resolution `openspec status` uses to detect the tasks
+ * 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.
+ */
+export declare function getTaskProgressForChange(changesDir: string, changeName: string, projectRoot: string): Promise<TaskProgress>;
 export declare function formatTaskStatus(progress: TaskProgress): string;
 //# sourceMappingURL=task-progress.d.ts.map

package/dist/utils/task-progress.js

@@ -1,23 +1,82 @@
 import { promises as fs } from 'fs';
 import path from 'path';
-const TASK_PATTERN = /^[-*]\s+\[[\sx]\]/i;
-const COMPLETED_TASK_PATTERN = /^[-*]\s+\[x\]/i;
-export function countTasksFromContent(content) {
-    const lines = content.split('\n');
-    let total = 0;
-    let completed = 0;
-    for (const line of lines) {
-        if (line.match(TASK_PATTERN)) {
-            total++;
-            if (line.match(COMPLETED_TASK_PATTERN)) {
-                completed++;
-            }
+import { resolveArtifactOutputs, resolveSchema } from '../core/artifact-graph/index.js';
+import { resolveSchemaForChange } from './change-metadata.js';
+/**
+ * A Markdown task line: a `-`/`*` bullet carrying a `[ ]` or `[x]` checkbox.
+ *
+ * Leading whitespace is allowed so nested sub-tasks count like their parents.
+ * Anchoring at column 0 made `  - [ ] 1.1.1 ...` invisible to progress, to the
+ * apply task list, and to archive's incomplete-task check, so a change with
+ * unfinished sub-tasks reported "✓ Complete" and archived without a warning.
+ *
+ * Permissive on purpose, and safe to keep that way: any character class
+ * tightened here - the `\s` inside the brackets, which lets a tab or
+ * non-breaking space stand for an empty box - drops lines that used to count,
+ * and a task this parser drops is a task `openspec archive` stops warning about.
+ *
+ * Deliberately unanchored at the end: `.` does not match `\r`, so writing the
+ * description group as `(.*)$` would reject every line of a CRLF tasks.md.
+ */
+const TASK_LINE_PATTERN = /^\s*[-*]\s*\[([\sxX])\]\s*(.*)/;
+/**
+ * Parses every task line in a tasks file, in document order.
+ *
+ * Every line matching the pattern counts, wherever it sits - inside a code
+ * fence, an HTML comment or an indented block, as before. Skipping fenced
+ * checkboxes was tried and dropped: every rule for deciding which fence is
+ * "real" has an input where a stray or unbalanced ``` swallows genuine tasks.
+ * Counting a documented example as work is a loud, bypassable false positive;
+ * losing a real task is a silent one.
+ */
+export function parseTaskLines(content) {
+    const tasks = [];
+    for (const line of content.split('\n')) {
+        const match = line.match(TASK_LINE_PATTERN);
+        if (match) {
+            tasks.push({ done: match[1].toLowerCase() === 'x', description: match[2].trim() });
         }
     }
-    return { total, completed };
+    return tasks;
 }
-export async function getTaskProgressForChange(changesDir, changeName) {
-    const tasksPath = path.join(changesDir, changeName, 'tasks.md');
+export function countTasksFromContent(content) {
+    const tasks = parseTaskLines(content);
+    return {
+        total: tasks.length,
+        completed: tasks.filter((task) => task.done).length,
+    };
+}
+/**
+ * Identifies the change's tracked-tasks artifact: the artifact whose `generates`
+ * equals the schema's `apply.tracks` value, falling back to the artifact with id
+ * `tasks` when no `apply` block declares what it tracks. (`apply.tracks` is a
+ * filename that *selects* the artifact; the glob is that artifact's `generates`.)
+ */
+function findTrackedTasksArtifact(schema) {
+    const tracks = schema.apply?.tracks;
+    if (tracks != null) {
+        return schema.artifacts.find((a) => a.generates === tracks);
+    }
+    return schema.artifacts.find((a) => a.id === 'tasks');
+}
+/**
+ * Resolves the tracked-tasks artifact's output glob for a change, or undefined
+ * 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.
+ */
+function resolveTrackedTasksGlob(changeDir, projectRoot) {
+    try {
+        const schemaName = resolveSchemaForChange(changeDir, undefined, projectRoot);
+        const schema = resolveSchema(schemaName, projectRoot);
+        return findTrackedTasksArtifact(schema)?.generates;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function countSingleTopLevelTasksFile(changeDir) {
+    const tasksPath = path.join(changeDir, 'tasks.md');
     try {
         const content = await fs.readFile(tasksPath, 'utf-8');
         return countTasksFromContent(content);
@@ -26,6 +85,41 @@ export async function getTaskProgressForChange(changesDir, changeName) {
         return { total: 0, completed: 0 };
     }
 }
+/** Resolves the task files selected by the schema's apply tracking rule. */
+export function resolveTaskFilesForChange(changeDir, projectRoot) {
+    const generates = resolveTrackedTasksGlob(changeDir, projectRoot);
+    return generates ? resolveArtifactOutputs(changeDir, generates) : [];
+}
+/**
+ * Computes a change's task progress by resolving its tracked-tasks artifact and
+ * counting checkboxes across every file matched by that artifact's `generates`
+ * glob — the same file-resolution `openspec status` uses to detect the tasks
+ * 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.
+ */
+export async function getTaskProgressForChange(changesDir, changeName, projectRoot) {
+    const changeDir = path.join(changesDir, changeName);
+    const files = resolveTaskFilesForChange(changeDir, projectRoot);
+    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 };
+    }
+    return countSingleTopLevelTasksFile(changeDir);
+}
 export function formatTaskStatus(progress) {
     if (progress.total === 0)
         return 'No tasks';