@wangjibins/openspec 1.2.2

package/dist/core/list.js

@@ -0,0 +1,171 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { MarkdownParser } from './parsers/markdown-parser.js';
+/**
+ * Get the most recent modification time of any file in a directory (recursive).
+ * Falls back to the directory's own mtime if no files are found.
+ */
+async function getLastModified(dirPath) {
+    let latest = null;
+    async function walk(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else {
+                const stat = await fs.stat(fullPath);
+                if (latest === null || stat.mtime > latest) {
+                    latest = stat.mtime;
+                }
+            }
+        }
+    }
+    await walk(dirPath);
+    // If no files found, use the directory's own modification time
+    if (latest === null) {
+        const dirStat = await fs.stat(dirPath);
+        return dirStat.mtime;
+    }
+    return latest;
+}
+/**
+ * Format a date as relative time (e.g., "2 hours ago", "3 days ago")
+ */
+function formatRelativeTime(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffSecs = Math.floor(diffMs / 1000);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffDays > 30) {
+        return date.toLocaleDateString();
+    }
+    else if (diffDays > 0) {
+        return `${diffDays}d ago`;
+    }
+    else if (diffHours > 0) {
+        return `${diffHours}h ago`;
+    }
+    else if (diffMins > 0) {
+        return `${diffMins}m ago`;
+    }
+    else {
+        return 'just now';
+    }
+}
+export class ListCommand {
+    async execute(targetPath = '.', mode = 'changes', options = {}) {
+        const { sort = 'recent', json = false } = options;
+        if (mode === 'changes') {
+            const changesDir = path.join(targetPath, 'openspec', 'changes');
+            // Check if changes directory exists
+            try {
+                await fs.access(changesDir);
+            }
+            catch {
+                throw new Error("No OpenSpec changes directory found. Run 'openspec init' first.");
+            }
+            // Get all directories in changes (excluding archive)
+            const entries = await fs.readdir(changesDir, { withFileTypes: true });
+            const changeDirs = entries
+                .filter(entry => entry.isDirectory() && entry.name !== 'archive')
+                .map(entry => entry.name);
+            if (changeDirs.length === 0) {
+                if (json) {
+                    console.log(JSON.stringify({ changes: [] }));
+                }
+                else {
+                    console.log('No active changes found.');
+                }
+                return;
+            }
+            // Collect information about each change
+            const changes = [];
+            for (const changeDir of changeDirs) {
+                const progress = await getTaskProgressForChange(changesDir, changeDir);
+                const changePath = path.join(changesDir, changeDir);
+                const lastModified = await getLastModified(changePath);
+                changes.push({
+                    name: changeDir,
+                    completedTasks: progress.completed,
+                    totalTasks: progress.total,
+                    lastModified
+                });
+            }
+            // Sort by preference (default: recent first)
+            if (sort === 'recent') {
+                changes.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+            }
+            else {
+                changes.sort((a, b) => a.name.localeCompare(b.name));
+            }
+            // JSON output for programmatic use
+            if (json) {
+                const jsonOutput = changes.map(c => ({
+                    name: c.name,
+                    completedTasks: c.completedTasks,
+                    totalTasks: c.totalTasks,
+                    lastModified: c.lastModified.toISOString(),
+                    status: c.totalTasks === 0 ? 'no-tasks' : c.completedTasks === c.totalTasks ? 'complete' : 'in-progress'
+                }));
+                console.log(JSON.stringify({ changes: jsonOutput }, null, 2));
+                return;
+            }
+            // Display results
+            console.log('Changes:');
+            const padding = '  ';
+            const nameWidth = Math.max(...changes.map(c => c.name.length));
+            for (const change of changes) {
+                const paddedName = change.name.padEnd(nameWidth);
+                const status = formatTaskStatus({ total: change.totalTasks, completed: change.completedTasks });
+                const timeAgo = formatRelativeTime(change.lastModified);
+                console.log(`${padding}${paddedName}     ${status.padEnd(12)}  ${timeAgo}`);
+            }
+            return;
+        }
+        // specs mode
+        const specsDir = path.join(targetPath, 'openspec', 'specs');
+        try {
+            await fs.access(specsDir);
+        }
+        catch {
+            console.log('No specs found.');
+            return;
+        }
+        const entries = await fs.readdir(specsDir, { withFileTypes: true });
+        const specDirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+        if (specDirs.length === 0) {
+            console.log('No specs found.');
+            return;
+        }
+        const specs = [];
+        for (const id of specDirs) {
+            const specPath = join(specsDir, id, 'spec.md');
+            try {
+                const content = readFileSync(specPath, 'utf-8');
+                const parser = new MarkdownParser(content);
+                const spec = parser.parseSpec(id);
+                specs.push({ id, requirementCount: spec.requirements.length });
+            }
+            catch {
+                // If spec cannot be read or parsed, include with 0 count
+                specs.push({ id, requirementCount: 0 });
+            }
+        }
+        specs.sort((a, b) => a.id.localeCompare(b.id));
+        console.log('Specs:');
+        const padding = '  ';
+        const nameWidth = Math.max(...specs.map(s => s.id.length));
+        for (const spec of specs) {
+            const padded = spec.id.padEnd(nameWidth);
+            console.log(`${padding}${padded}     requirements ${spec.requirementCount}`);
+        }
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/core/migration.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Migration Utilities
+ *
+ * One-time migration logic for existing projects when profile system is introduced.
+ * Called by both init and update commands before profile resolution.
+ */
+import type { AIToolOption } from './config.js';
+/**
+ * Scans installed workflow files across all detected tools and returns
+ * the union of installed workflow IDs.
+ */
+export declare function scanInstalledWorkflows(projectPath: string, tools: AIToolOption[]): string[];
+/**
+ * Performs one-time migration if the global config does not yet have a profile field.
+ * Called by both init and update before profile resolution.
+ *
+ * - If no profile field exists and workflows are installed: sets profile to 'custom'
+ *   with the detected workflows, preserving the user's existing setup.
+ * - If no profile field exists and no workflows are installed: no-op (defaults apply).
+ * - If profile field already exists: no-op.
+ */
+export declare function migrateIfNeeded(projectPath: string, tools: AIToolOption[]): void;
+//# sourceMappingURL=migration.d.ts.map

package/dist/core/migration.js

@@ -0,0 +1,108 @@
+/**
+ * Migration Utilities
+ *
+ * One-time migration logic for existing projects when profile system is introduced.
+ * Called by both init and update commands before profile resolution.
+ */
+import { getGlobalConfig, getGlobalConfigPath, saveGlobalConfig } from './global-config.js';
+import { CommandAdapterRegistry } from './command-generation/index.js';
+import { WORKFLOW_TO_SKILL_DIR } from './profile-sync-drift.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+import path from 'path';
+import * as fs from 'fs';
+function scanInstalledWorkflowArtifacts(projectPath, tools) {
+    const installed = new Set();
+    let hasSkills = false;
+    let hasCommands = false;
+    for (const tool of tools) {
+        if (!tool.skillsDir)
+            continue;
+        const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+        for (const workflowId of ALL_WORKFLOWS) {
+            const skillDirName = WORKFLOW_TO_SKILL_DIR[workflowId];
+            const skillFile = path.join(skillsDir, skillDirName, 'SKILL.md');
+            if (fs.existsSync(skillFile)) {
+                installed.add(workflowId);
+                hasSkills = true;
+            }
+        }
+        const adapter = CommandAdapterRegistry.get(tool.value);
+        if (!adapter)
+            continue;
+        for (const workflowId of ALL_WORKFLOWS) {
+            const commandPath = adapter.getFilePath(workflowId);
+            const fullPath = path.isAbsolute(commandPath)
+                ? commandPath
+                : path.join(projectPath, commandPath);
+            if (fs.existsSync(fullPath)) {
+                installed.add(workflowId);
+                hasCommands = true;
+            }
+        }
+    }
+    return {
+        workflows: ALL_WORKFLOWS.filter((workflowId) => installed.has(workflowId)),
+        hasSkills,
+        hasCommands,
+    };
+}
+/**
+ * Scans installed workflow files across all detected tools and returns
+ * the union of installed workflow IDs.
+ */
+export function scanInstalledWorkflows(projectPath, tools) {
+    return scanInstalledWorkflowArtifacts(projectPath, tools).workflows;
+}
+function inferDelivery(artifacts) {
+    if (artifacts.hasSkills && artifacts.hasCommands) {
+        return 'both';
+    }
+    if (artifacts.hasCommands) {
+        return 'commands';
+    }
+    return 'skills';
+}
+/**
+ * Performs one-time migration if the global config does not yet have a profile field.
+ * Called by both init and update before profile resolution.
+ *
+ * - If no profile field exists and workflows are installed: sets profile to 'custom'
+ *   with the detected workflows, preserving the user's existing setup.
+ * - If no profile field exists and no workflows are installed: no-op (defaults apply).
+ * - If profile field already exists: no-op.
+ */
+export function migrateIfNeeded(projectPath, tools) {
+    const config = getGlobalConfig();
+    // Check raw config file for profile field presence
+    const configPath = getGlobalConfigPath();
+    let rawConfig = {};
+    try {
+        if (fs.existsSync(configPath)) {
+            rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+    }
+    catch {
+        return; // Can't read config, skip migration
+    }
+    // If profile is already explicitly set, no migration needed
+    if (rawConfig.profile !== undefined) {
+        return;
+    }
+    // Scan for installed workflows
+    const artifacts = scanInstalledWorkflowArtifacts(projectPath, tools);
+    const installedWorkflows = artifacts.workflows;
+    if (installedWorkflows.length === 0) {
+        // No workflows installed, new user — defaults will apply
+        return;
+    }
+    // Migrate: set profile to custom with detected workflows
+    config.profile = 'custom';
+    config.workflows = installedWorkflows;
+    if (rawConfig.delivery === undefined) {
+        config.delivery = inferDelivery(artifacts);
+    }
+    saveGlobalConfig(config);
+    console.log(`Migrated: custom profile with ${installedWorkflows.length} workflows`);
+    console.log("New in this version: /opsx:propose. Try 'openspec config profile core' for the streamlined experience.");
+}
+//# sourceMappingURL=migration.js.map

package/dist/core/parsers/change-parser.d.ts

@@ -0,0 +1,13 @@
+import { MarkdownParser } from './markdown-parser.js';
+import { Change } from '../schemas/index.js';
+export declare class ChangeParser extends MarkdownParser {
+    private changeDir;
+    constructor(content: string, changeDir: string);
+    parseChangeWithDeltas(name: string): Promise<Change>;
+    private parseDeltaSpecs;
+    private parseSpecDeltas;
+    private parseRenames;
+    private parseSectionsFromContent;
+    private getContentUntilNextHeaderFromLines;
+}
+//# sourceMappingURL=change-parser.d.ts.map

package/dist/core/parsers/change-parser.js

@@ -0,0 +1,193 @@
+import { MarkdownParser } from './markdown-parser.js';
+import path from 'path';
+import { promises as fs } from 'fs';
+export class ChangeParser extends MarkdownParser {
+    changeDir;
+    constructor(content, changeDir) {
+        super(content);
+        this.changeDir = changeDir;
+    }
+    async parseChangeWithDeltas(name) {
+        const sections = this.parseSections();
+        const why = this.findSection(sections, 'Why')?.content || '';
+        const whatChanges = this.findSection(sections, 'What Changes')?.content || '';
+        if (!why) {
+            throw new Error('Change must have a Why section');
+        }
+        if (!whatChanges) {
+            throw new Error('Change must have a What Changes section');
+        }
+        // Parse deltas from the What Changes section (simple format)
+        const simpleDeltas = this.parseDeltas(whatChanges);
+        // Check if there are spec files with delta format
+        const specsDir = path.join(this.changeDir, 'specs');
+        const deltaDeltas = await this.parseDeltaSpecs(specsDir);
+        // Combine both types of deltas, preferring delta format if available
+        const deltas = deltaDeltas.length > 0 ? deltaDeltas : simpleDeltas;
+        return {
+            name,
+            why: why.trim(),
+            whatChanges: whatChanges.trim(),
+            deltas,
+            metadata: {
+                version: '1.0.0',
+                format: 'openspec-change',
+            },
+        };
+    }
+    async parseDeltaSpecs(specsDir) {
+        const deltas = [];
+        try {
+            const specDirs = await fs.readdir(specsDir, { withFileTypes: true });
+            for (const dir of specDirs) {
+                if (!dir.isDirectory())
+                    continue;
+                const specName = dir.name;
+                const specFile = path.join(specsDir, specName, 'spec.md');
+                try {
+                    const content = await fs.readFile(specFile, 'utf-8');
+                    const specDeltas = this.parseSpecDeltas(specName, content);
+                    deltas.push(...specDeltas);
+                }
+                catch (error) {
+                    // Spec file might not exist, which is okay
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            // Specs directory might not exist, which is okay
+            return [];
+        }
+        return deltas;
+    }
+    parseSpecDeltas(specName, content) {
+        const deltas = [];
+        const sections = this.parseSectionsFromContent(content);
+        // Parse ADDED requirements
+        const addedSection = this.findSection(sections, 'ADDED Requirements');
+        if (addedSection) {
+            const requirements = this.parseRequirements(addedSection);
+            requirements.forEach(req => {
+                deltas.push({
+                    spec: specName,
+                    operation: 'ADDED',
+                    description: `Add requirement: ${req.text}`,
+                    // Provide both single and plural forms for compatibility
+                    requirement: req,
+                    requirements: [req],
+                });
+            });
+        }
+        // Parse MODIFIED requirements
+        const modifiedSection = this.findSection(sections, 'MODIFIED Requirements');
+        if (modifiedSection) {
+            const requirements = this.parseRequirements(modifiedSection);
+            requirements.forEach(req => {
+                deltas.push({
+                    spec: specName,
+                    operation: 'MODIFIED',
+                    description: `Modify requirement: ${req.text}`,
+                    requirement: req,
+                    requirements: [req],
+                });
+            });
+        }
+        // Parse REMOVED requirements
+        const removedSection = this.findSection(sections, 'REMOVED Requirements');
+        if (removedSection) {
+            const requirements = this.parseRequirements(removedSection);
+            requirements.forEach(req => {
+                deltas.push({
+                    spec: specName,
+                    operation: 'REMOVED',
+                    description: `Remove requirement: ${req.text}`,
+                    requirement: req,
+                    requirements: [req],
+                });
+            });
+        }
+        // Parse RENAMED requirements
+        const renamedSection = this.findSection(sections, 'RENAMED Requirements');
+        if (renamedSection) {
+            const renames = this.parseRenames(renamedSection.content);
+            renames.forEach(rename => {
+                deltas.push({
+                    spec: specName,
+                    operation: 'RENAMED',
+                    description: `Rename requirement from "${rename.from}" to "${rename.to}"`,
+                    rename,
+                });
+            });
+        }
+        return deltas;
+    }
+    parseRenames(content) {
+        const renames = [];
+        const lines = ChangeParser.normalizeContent(content).split('\n');
+        let currentRename = {};
+        for (const line of lines) {
+            const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+            const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+            if (fromMatch) {
+                currentRename.from = fromMatch[1].trim();
+            }
+            else if (toMatch) {
+                currentRename.to = toMatch[1].trim();
+                if (currentRename.from && currentRename.to) {
+                    renames.push({
+                        from: currentRename.from,
+                        to: currentRename.to,
+                    });
+                    currentRename = {};
+                }
+            }
+        }
+        return renames;
+    }
+    parseSectionsFromContent(content) {
+        const normalizedContent = ChangeParser.normalizeContent(content);
+        const lines = normalizedContent.split('\n');
+        const sections = [];
+        const stack = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headerMatch) {
+                const level = headerMatch[1].length;
+                const title = headerMatch[2].trim();
+                const contentLines = this.getContentUntilNextHeaderFromLines(lines, i + 1, level);
+                const section = {
+                    level,
+                    title,
+                    content: contentLines.join('\n').trim(),
+                    children: [],
+                };
+                while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+                    stack.pop();
+                }
+                if (stack.length === 0) {
+                    sections.push(section);
+                }
+                else {
+                    stack[stack.length - 1].children.push(section);
+                }
+                stack.push(section);
+            }
+        }
+        return sections;
+    }
+    getContentUntilNextHeaderFromLines(lines, startLine, currentLevel) {
+        const contentLines = [];
+        for (let i = startLine; i < lines.length; i++) {
+            const line = lines[i];
+            const headerMatch = line.match(/^(#{1,6})\s+/);
+            if (headerMatch && headerMatch[1].length <= currentLevel) {
+                break;
+            }
+            contentLines.push(line);
+        }
+        return contentLines;
+    }
+}
+//# sourceMappingURL=change-parser.js.map

package/dist/core/parsers/markdown-parser.d.ts

@@ -0,0 +1,22 @@
+import { Spec, Change, Requirement, Scenario, Delta } from '../schemas/index.js';
+export interface Section {
+    level: number;
+    title: string;
+    content: string;
+    children: Section[];
+}
+export declare class MarkdownParser {
+    private lines;
+    private currentLine;
+    constructor(content: string);
+    protected static normalizeContent(content: string): string;
+    parseSpec(name: string): Spec;
+    parseChange(name: string): Change;
+    protected parseSections(): Section[];
+    protected getContentUntilNextHeader(startLine: number, currentLevel: number): string;
+    protected findSection(sections: Section[], title: string): Section | undefined;
+    protected parseRequirements(section: Section): Requirement[];
+    protected parseScenarios(requirementSection: Section): Scenario[];
+    protected parseDeltas(content: string): Delta[];
+}
+//# sourceMappingURL=markdown-parser.d.ts.map