anchorspec 1.3.0

package/dist/utils/change-utils.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Options for creating a change.
+ */
+export interface CreateChangeOptions {
+    /** The workflow schema to use (default: 'spec-driven') */
+    schema?: string;
+}
+/**
+ * Result of creating a change.
+ */
+export interface CreateChangeResult {
+    /** The schema that was actually used (resolved from options, config, or default) */
+    schema: string;
+}
+/**
+ * Result of validating a change name.
+ */
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * Validates that a change name follows kebab-case conventions.
+ *
+ * Valid names:
+ * - Start with a lowercase letter
+ * - Contain only lowercase letters, numbers, and hyphens
+ * - Do not start or end with a hyphen
+ * - Do not contain consecutive hyphens
+ *
+ * @param name - The change name to validate
+ * @returns Validation result with `valid: true` or `valid: false` with an error message
+ *
+ * @example
+ * validateChangeName('add-auth') // { valid: true }
+ * validateChangeName('Add-Auth') // { valid: false, error: '...' }
+ */
+export declare function validateChangeName(name: string): ValidationResult;
+/**
+ * Creates a new change directory with metadata file.
+ *
+ * @param projectRoot - The root directory of the project (where `openspec/` lives)
+ * @param name - The change name (must be valid kebab-case)
+ * @param options - Optional settings for the change
+ * @throws Error if the change name is invalid
+ * @throws Error if the schema name is invalid
+ * @throws Error if the change directory already exists
+ *
+ * @returns Result containing the resolved schema name
+ *
+ * @example
+ * // Creates openspec/changes/add-auth/ with default schema
+ * const result = await createChange('/path/to/project', 'add-auth')
+ * console.log(result.schema) // 'spec-driven' or value from config
+ *
+ * @example
+ * // Creates openspec/changes/add-auth/ with custom schema
+ * const result = await createChange('/path/to/project', 'add-auth', { schema: 'my-workflow' })
+ * console.log(result.schema) // 'my-workflow'
+ */
+export declare function createChange(projectRoot: string, name: string, options?: CreateChangeOptions): Promise<CreateChangeResult>;
+//# sourceMappingURL=change-utils.d.ts.map

package/dist/utils/change-utils.js

@@ -0,0 +1,121 @@
+import path from 'path';
+import { FileSystemUtils } from './file-system.js';
+import { writeChangeMetadata, validateSchemaName } from './change-metadata.js';
+import { readProjectConfig } from '../core/project-config.js';
+const DEFAULT_SCHEMA = 'spec-driven';
+/**
+ * Validates that a change name follows kebab-case conventions.
+ *
+ * Valid names:
+ * - Start with a lowercase letter
+ * - Contain only lowercase letters, numbers, and hyphens
+ * - Do not start or end with a hyphen
+ * - Do not contain consecutive hyphens
+ *
+ * @param name - The change name to validate
+ * @returns Validation result with `valid: true` or `valid: false` with an error message
+ *
+ * @example
+ * validateChangeName('add-auth') // { valid: true }
+ * validateChangeName('Add-Auth') // { valid: false, error: '...' }
+ */
+export function validateChangeName(name) {
+    // Pattern: starts with lowercase letter, followed by lowercase letters/numbers,
+    // optionally followed by hyphen + lowercase letters/numbers (repeatable)
+    const kebabCasePattern = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+    if (!name) {
+        return { valid: false, error: 'Change name cannot be empty' };
+    }
+    if (!kebabCasePattern.test(name)) {
+        // Provide specific error messages for common mistakes
+        if (/[A-Z]/.test(name)) {
+            return { valid: false, error: 'Change name must be lowercase (use kebab-case)' };
+        }
+        if (/\s/.test(name)) {
+            return { valid: false, error: 'Change name cannot contain spaces (use hyphens instead)' };
+        }
+        if (/_/.test(name)) {
+            return { valid: false, error: 'Change name cannot contain underscores (use hyphens instead)' };
+        }
+        if (name.startsWith('-')) {
+            return { valid: false, error: 'Change name cannot start with a hyphen' };
+        }
+        if (name.endsWith('-')) {
+            return { valid: false, error: 'Change name cannot end with a hyphen' };
+        }
+        if (/--/.test(name)) {
+            return { valid: false, error: 'Change name cannot contain consecutive hyphens' };
+        }
+        if (/[^a-z0-9-]/.test(name)) {
+            return { valid: false, error: 'Change name can only contain lowercase letters, numbers, and hyphens' };
+        }
+        if (/^[0-9]/.test(name)) {
+            return { valid: false, error: 'Change name must start with a letter' };
+        }
+        return { valid: false, error: 'Change name must follow kebab-case convention (e.g., add-auth, refactor-db)' };
+    }
+    return { valid: true };
+}
+/**
+ * Creates a new change directory with metadata file.
+ *
+ * @param projectRoot - The root directory of the project (where `anchorspec/` lives)
+ * @param name - The change name (must be valid kebab-case)
+ * @param options - Optional settings for the change
+ * @throws Error if the change name is invalid
+ * @throws Error if the schema name is invalid
+ * @throws Error if the change directory already exists
+ *
+ * @returns Result containing the resolved schema name
+ *
+ * @example
+ * // Creates anchorspec/changes/add-auth/ with default schema
+ * const result = await createChange('/path/to/project', 'add-auth')
+ * console.log(result.schema) // 'spec-driven' or value from config
+ *
+ * @example
+ * // Creates anchorspec/changes/add-auth/ with custom schema
+ * const result = await createChange('/path/to/project', 'add-auth', { schema: 'my-workflow' })
+ * console.log(result.schema) // 'my-workflow'
+ */
+export async function createChange(projectRoot, name, options = {}) {
+    // Validate the name first
+    const validation = validateChangeName(name);
+    if (!validation.valid) {
+        throw new Error(validation.error);
+    }
+    // Determine schema: explicit option → project config → hardcoded default
+    let schemaName;
+    if (options.schema) {
+        schemaName = options.schema;
+    }
+    else {
+        // Try to read from project config
+        try {
+            const config = readProjectConfig(projectRoot);
+            schemaName = config?.schema ?? DEFAULT_SCHEMA;
+        }
+        catch {
+            // If config read fails, use default
+            schemaName = DEFAULT_SCHEMA;
+        }
+    }
+    // Validate the resolved schema
+    validateSchemaName(schemaName, projectRoot);
+    // Build the change directory path
+    const changeDir = path.join(projectRoot, 'anchorspec', 'changes', name);
+    // Check if change already exists
+    if (await FileSystemUtils.directoryExists(changeDir)) {
+        throw new Error(`Change '${name}' already exists at ${changeDir}`);
+    }
+    // Create the directory (including parent directories if needed)
+    await FileSystemUtils.createDirectory(changeDir);
+    // Write metadata file with schema and creation date
+    const today = new Date().toISOString().split('T')[0];
+    writeChangeMetadata(changeDir, {
+        schema: schemaName,
+        created: today,
+    }, projectRoot);
+    return { schema: schemaName };
+}
+//# sourceMappingURL=change-utils.js.map

package/dist/utils/command-references.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Command Reference Utilities
+ *
+ * Utilities for transforming command references to tool-specific formats.
+ */
+/**
+ * Transforms colon-based command references to hyphen-based format.
+ * Converts `/opsx:` patterns to `/opsx-` for tools that use hyphen syntax.
+ *
+ * @param text - The text containing command references
+ * @returns Text with command references transformed to hyphen format
+ *
+ * @example
+ * transformToHyphenCommands('/opsx:new') // returns '/opsx-new'
+ * transformToHyphenCommands('Use /opsx:apply to implement') // returns 'Use /opsx-apply to implement'
+ */
+export declare function transformToHyphenCommands(text: string): string;
+//# sourceMappingURL=command-references.d.ts.map

package/dist/utils/command-references.js

@@ -0,0 +1,20 @@
+/**
+ * Command Reference Utilities
+ *
+ * Utilities for transforming command references to tool-specific formats.
+ */
+/**
+ * Transforms colon-based command references to hyphen-based format.
+ * Converts `/ansx:` patterns to `/ansx-` for tools that use hyphen syntax.
+ *
+ * @param text - The text containing command references
+ * @returns Text with command references transformed to hyphen format
+ *
+ * @example
+ * transformToHyphenCommands('/ansx:new') // returns '/ansx-new'
+ * transformToHyphenCommands('Use /ansx:apply to implement') // returns 'Use /ansx-apply to implement'
+ */
+export function transformToHyphenCommands(text) {
+    return text.replace(/\/ansx:/g, '/ansx-');
+}
+//# sourceMappingURL=command-references.js.map

package/dist/utils/file-system.d.ts

@@ -0,0 +1,36 @@
+export declare class FileSystemUtils {
+    /**
+     * Converts a path to use forward slashes (POSIX style).
+     * Essential for cross-platform compatibility with glob libraries like fast-glob.
+     */
+    static toPosixPath(p: string): string;
+    private static isWindowsBasePath;
+    private static normalizeSegments;
+    static joinPath(basePath: string, ...segments: string[]): string;
+    static createDirectory(dirPath: string): Promise<void>;
+    static fileExists(filePath: string): Promise<boolean>;
+    /**
+     * Finds the first existing parent directory by walking up the directory tree.
+     * @param dirPath Starting directory path
+     * @returns The first existing directory path, or null if root is reached without finding one
+     */
+    private static findFirstExistingDirectory;
+    static canWriteFile(filePath: string): Promise<boolean>;
+    static directoryExists(dirPath: string): Promise<boolean>;
+    static writeFile(filePath: string, content: string): Promise<void>;
+    static readFile(filePath: string): Promise<string>;
+    static updateFileWithMarkers(filePath: string, content: string, startMarker: string, endMarker: string): Promise<void>;
+    static ensureWritePermissions(dirPath: string): Promise<boolean>;
+}
+/**
+ * Removes a marker block from file content.
+ * Only removes markers that are on their own lines (ignores inline mentions).
+ * Cleans up double blank lines that may result from removal.
+ *
+ * @param content - File content with markers
+ * @param startMarker - The start marker string
+ * @param endMarker - The end marker string
+ * @returns Content with marker block removed, or original content if markers not found/invalid
+ */
+export declare function removeMarkerBlock(content: string, startMarker: string, endMarker: string): string;
+//# sourceMappingURL=file-system.d.ts.map

package/dist/utils/file-system.js

@@ -0,0 +1,281 @@
+import { promises as fs, constants as fsConstants } from 'fs';
+import path from 'path';
+function isMarkerOnOwnLine(content, markerIndex, markerLength) {
+    let leftIndex = markerIndex - 1;
+    while (leftIndex >= 0 && content[leftIndex] !== '\n') {
+        const char = content[leftIndex];
+        if (char !== ' ' && char !== '\t' && char !== '\r') {
+            return false;
+        }
+        leftIndex--;
+    }
+    let rightIndex = markerIndex + markerLength;
+    while (rightIndex < content.length && content[rightIndex] !== '\n') {
+        const char = content[rightIndex];
+        if (char !== ' ' && char !== '\t' && char !== '\r') {
+            return false;
+        }
+        rightIndex++;
+    }
+    return true;
+}
+function findMarkerIndex(content, marker, fromIndex = 0) {
+    let currentIndex = content.indexOf(marker, fromIndex);
+    while (currentIndex !== -1) {
+        if (isMarkerOnOwnLine(content, currentIndex, marker.length)) {
+            return currentIndex;
+        }
+        currentIndex = content.indexOf(marker, currentIndex + marker.length);
+    }
+    return -1;
+}
+export class FileSystemUtils {
+    /**
+     * Converts a path to use forward slashes (POSIX style).
+     * Essential for cross-platform compatibility with glob libraries like fast-glob.
+     */
+    static toPosixPath(p) {
+        return p.replace(/\\/g, '/');
+    }
+    static isWindowsBasePath(basePath) {
+        return /^[A-Za-z]:[\\/]/.test(basePath) || basePath.startsWith('\\');
+    }
+    static normalizeSegments(segments) {
+        return segments
+            .flatMap((segment) => segment.split(/[\\/]+/u))
+            .filter((part) => part.length > 0);
+    }
+    static joinPath(basePath, ...segments) {
+        const normalizedSegments = this.normalizeSegments(segments);
+        if (this.isWindowsBasePath(basePath)) {
+            const normalizedBasePath = path.win32.normalize(basePath);
+            return normalizedSegments.length
+                ? path.win32.join(normalizedBasePath, ...normalizedSegments)
+                : normalizedBasePath;
+        }
+        const posixBasePath = basePath.replace(/\\/g, '/');
+        return normalizedSegments.length
+            ? path.posix.join(posixBasePath, ...normalizedSegments)
+            : path.posix.normalize(posixBasePath);
+    }
+    static async createDirectory(dirPath) {
+        await fs.mkdir(dirPath, { recursive: true });
+    }
+    static async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.debug(`Unable to check if file exists at ${filePath}: ${error.message}`);
+            }
+            return false;
+        }
+    }
+    /**
+     * Finds the first existing parent directory by walking up the directory tree.
+     * @param dirPath Starting directory path
+     * @returns The first existing directory path, or null if root is reached without finding one
+     */
+    static async findFirstExistingDirectory(dirPath) {
+        let currentDir = dirPath;
+        while (true) {
+            try {
+                const stats = await fs.stat(currentDir);
+                if (stats.isDirectory()) {
+                    return currentDir;
+                }
+                // Path component exists but is not a directory (edge case)
+                console.debug(`Path component ${currentDir} exists but is not a directory`);
+                return null;
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    // Directory doesn't exist, move up one level
+                    const parentDir = path.dirname(currentDir);
+                    if (parentDir === currentDir) {
+                        // Reached filesystem root without finding existing directory
+                        return null;
+                    }
+                    currentDir = parentDir;
+                }
+                else {
+                    // Unexpected error (permissions, I/O error, etc.)
+                    console.debug(`Error checking directory ${currentDir}: ${error.message}`);
+                    return null;
+                }
+            }
+        }
+    }
+    static async canWriteFile(filePath) {
+        try {
+            const stats = await fs.stat(filePath);
+            if (!stats.isFile()) {
+                return true;
+            }
+            // On Windows, stats.mode doesn't reliably indicate write permissions.
+            // Use fs.access with W_OK to check actual write permissions cross-platform.
+            try {
+                await fs.access(filePath, fsConstants.W_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist - find first existing parent directory and check its permissions
+                const parentDir = path.dirname(filePath);
+                const existingDir = await this.findFirstExistingDirectory(parentDir);
+                if (existingDir === null) {
+                    // No existing parent directory found (edge case)
+                    return false;
+                }
+                // Check if the existing parent directory is writable
+                try {
+                    await fs.access(existingDir, fsConstants.W_OK);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }
+            console.debug(`Unable to determine write permissions for ${filePath}: ${error.message}`);
+            return false;
+        }
+    }
+    static async directoryExists(dirPath) {
+        try {
+            const stats = await fs.stat(dirPath);
+            return stats.isDirectory();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.debug(`Unable to check if directory exists at ${dirPath}: ${error.message}`);
+            }
+            return false;
+        }
+    }
+    static async writeFile(filePath, content) {
+        const dir = path.dirname(filePath);
+        await this.createDirectory(dir);
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+    static async readFile(filePath) {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    static async updateFileWithMarkers(filePath, content, startMarker, endMarker) {
+        let existingContent = '';
+        if (await this.fileExists(filePath)) {
+            existingContent = await this.readFile(filePath);
+            const startIndex = findMarkerIndex(existingContent, startMarker);
+            const endIndex = startIndex !== -1
+                ? findMarkerIndex(existingContent, endMarker, startIndex + startMarker.length)
+                : findMarkerIndex(existingContent, endMarker);
+            if (startIndex !== -1 && endIndex !== -1) {
+                if (endIndex < startIndex) {
+                    throw new Error(`Invalid marker state in ${filePath}. End marker appears before start marker.`);
+                }
+                const before = existingContent.substring(0, startIndex);
+                const after = existingContent.substring(endIndex + endMarker.length);
+                existingContent = before + startMarker + '\n' + content + '\n' + endMarker + after;
+            }
+            else if (startIndex === -1 && endIndex === -1) {
+                existingContent = startMarker + '\n' + content + '\n' + endMarker + '\n\n' + existingContent;
+            }
+            else {
+                throw new Error(`Invalid marker state in ${filePath}. Found start: ${startIndex !== -1}, Found end: ${endIndex !== -1}`);
+            }
+        }
+        else {
+            existingContent = startMarker + '\n' + content + '\n' + endMarker;
+        }
+        await this.writeFile(filePath, existingContent);
+    }
+    static async ensureWritePermissions(dirPath) {
+        try {
+            // If directory doesn't exist, check parent directory permissions
+            if (!await this.directoryExists(dirPath)) {
+                const parentDir = path.dirname(dirPath);
+                if (!await this.directoryExists(parentDir)) {
+                    await this.createDirectory(parentDir);
+                }
+                return await this.ensureWritePermissions(parentDir);
+            }
+            const testFile = path.join(dirPath, '.anchorspec-test-' + Date.now() + '-' + Math.random().toString(36).slice(2));
+            await fs.writeFile(testFile, '');
+            // On Windows, file may be temporarily locked by antivirus or indexing services.
+            // Retry unlink with a small delay if it fails.
+            const maxRetries = 3;
+            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                try {
+                    await fs.unlink(testFile);
+                    break;
+                }
+                catch (unlinkError) {
+                    if (attempt === maxRetries - 1) {
+                        // Last attempt failed, but we successfully wrote the file, so permissions are OK
+                        // Just log and continue - the temp file will be cleaned up eventually
+                        console.debug(`Could not clean up test file ${testFile}: ${unlinkError.message}`);
+                    }
+                    else {
+                        // Wait briefly before retrying (Windows file lock release)
+                        await new Promise((resolve) => setTimeout(resolve, 50));
+                    }
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            console.debug(`Insufficient permissions to write to ${dirPath}: ${error.message}`);
+            return false;
+        }
+    }
+}
+/**
+ * Removes a marker block from file content.
+ * Only removes markers that are on their own lines (ignores inline mentions).
+ * Cleans up double blank lines that may result from removal.
+ *
+ * @param content - File content with markers
+ * @param startMarker - The start marker string
+ * @param endMarker - The end marker string
+ * @returns Content with marker block removed, or original content if markers not found/invalid
+ */
+export function removeMarkerBlock(content, startMarker, endMarker) {
+    const startIndex = findMarkerIndex(content, startMarker);
+    const endIndex = startIndex !== -1
+        ? findMarkerIndex(content, endMarker, startIndex + startMarker.length)
+        : findMarkerIndex(content, endMarker);
+    if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
+        return content;
+    }
+    // Find the start of the line containing the start marker
+    let lineStart = startIndex;
+    while (lineStart > 0 && content[lineStart - 1] !== '\n') {
+        lineStart--;
+    }
+    // Find the end of the line containing the end marker
+    let lineEnd = endIndex + endMarker.length;
+    while (lineEnd < content.length && content[lineEnd] !== '\n') {
+        lineEnd++;
+    }
+    // Include the trailing newline if present
+    if (lineEnd < content.length && content[lineEnd] === '\n') {
+        lineEnd++;
+    }
+    const before = content.substring(0, lineStart);
+    const after = content.substring(lineEnd);
+    // Clean up double blank lines (handle both Unix \n and Windows \r\n)
+    let result = before + after;
+    result = result.replace(/(\r?\n){3,}/g, '\n\n');
+    // Trim trailing whitespace but preserve leading whitespace and original newline style
+    if (result.trimEnd() === '') {
+        return '';
+    }
+    const newline = content.includes('\r\n') ? '\r\n' : '\n';
+    return result.trimEnd() + newline;
+}
+//# sourceMappingURL=file-system.js.map

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export { validateChangeName, createChange } from './change-utils.js';
+export type { ValidationResult, CreateChangeOptions } from './change-utils.js';
+export { readChangeMetadata, writeChangeMetadata, resolveSchemaForChange, validateSchemaName, ChangeMetadataError, } from './change-metadata.js';
+export { FileSystemUtils, removeMarkerBlock } from './file-system.js';
+export { transformToHyphenCommands } from './command-references.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -0,0 +1,9 @@
+// Shared utilities
+export { validateChangeName, createChange } from './change-utils.js';
+// Change metadata utilities
+export { readChangeMetadata, writeChangeMetadata, resolveSchemaForChange, validateSchemaName, ChangeMetadataError, } from './change-metadata.js';
+// File system utilities
+export { FileSystemUtils, removeMarkerBlock } from './file-system.js';
+// Command reference utilities
+export { transformToHyphenCommands } from './command-references.js';
+//# sourceMappingURL=index.js.map

package/dist/utils/interactive.d.ts

@@ -0,0 +1,18 @@
+export type InteractiveOptions = {
+    /**
+     * Explicit "disable prompts" flag passed by internal callers.
+     */
+    noInteractive?: boolean;
+    /**
+     * Commander-style negated option: `--no-interactive` sets this to false.
+     */
+    interactive?: boolean;
+};
+/**
+ * Resolves whether non-interactive mode is requested.
+ * Handles both explicit `noInteractive: true` and Commander.js style `interactive: false`.
+ * Use this helper instead of manually checking options.noInteractive to avoid bugs.
+ */
+export declare function resolveNoInteractive(value?: boolean | InteractiveOptions): boolean;
+export declare function isInteractive(value?: boolean | InteractiveOptions): boolean;
+//# sourceMappingURL=interactive.d.ts.map

package/dist/utils/interactive.js

@@ -0,0 +1,21 @@
+/**
+ * Resolves whether non-interactive mode is requested.
+ * Handles both explicit `noInteractive: true` and Commander.js style `interactive: false`.
+ * Use this helper instead of manually checking options.noInteractive to avoid bugs.
+ */
+export function resolveNoInteractive(value) {
+    if (typeof value === 'boolean')
+        return value;
+    return value?.noInteractive === true || value?.interactive === false;
+}
+export function isInteractive(value) {
+    if (resolveNoInteractive(value))
+        return false;
+    if (process.env.OPEN_SPEC_INTERACTIVE === '0')
+        return false;
+    // Respect the standard CI environment variable (set by GitHub Actions, GitLab CI, Travis, etc.)
+    if ('CI' in process.env)
+        return false;
+    return !!process.stdin.isTTY;
+}
+//# sourceMappingURL=interactive.js.map

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

@@ -0,0 +1,4 @@
+export declare function getActiveChangeIds(root?: string): Promise<string[]>;
+export declare function getSpecIds(root?: string): Promise<string[]>;
+export declare function getArchivedChangeIds(root?: string): Promise<string[]>;
+//# sourceMappingURL=item-discovery.d.ts.map

package/dist/utils/item-discovery.js

@@ -0,0 +1,72 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+export async function getActiveChangeIds(root = process.cwd()) {
+    const changesPath = path.join(root, 'anchorspec', '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();
+    }
+    catch {
+        return [];
+    }
+}
+export async function getSpecIds(root = process.cwd()) {
+    const specsPath = path.join(root, 'anchorspec', '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();
+}
+export async function getArchivedChangeIds(root = process.cwd()) {
+    const archivePath = path.join(root, 'anchorspec', '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();
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=item-discovery.js.map