@thiagodiogo/pscode 1.0.0

package/dist/core/openspec-migration.js

@@ -0,0 +1,320 @@
+/**
+ * Legacy Tool → Pscode Migration
+ *
+ * Detects projects using the old "openspec" structure and migrates them
+ * cleanly to Pscode: deletes old skills/commands generated by openspec
+ * (opsx-* prefix), renames the .openspec/ folder to pscode/, and
+ * migrates any stale config fields.
+ *
+ * Migration is triggered automatically during `pscode init` when an
+ * .openspec/ directory is detected. The user is prompted to confirm before
+ * any changes are made.
+ */
+import path from 'path';
+import { promises as fs } from 'fs';
+import chalk from 'chalk';
+import { AI_TOOLS } from './config.js';
+import { CommandAdapterRegistry } from './command-generation/index.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+import { FileSystemUtils } from '../utils/file-system.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/**
+ * Candidate directory names used by the old openspec tool.
+ * Check both "openspec" (without dot) and ".openspec" (with dot).
+ */
+const OPENSPEC_DIR_CANDIDATES = ['openspec', '.openspec'];
+/** Old skill prefix used by openspec */
+const OPENSPEC_SKILL_PREFIX = 'opsx-';
+/** Old slash command prefix used by openspec */
+const OPENSPEC_COMMAND_PREFIX = 'opsx-';
+/** Old slash command namespaces (subdirectories inside commands/) to remove */
+const OPENSPEC_COMMAND_DIRS = ['opsx', 'openspec'];
+// ---------------------------------------------------------------------------
+// Detection
+// ---------------------------------------------------------------------------
+/**
+ * Detects legacy tool artifacts in a project.
+ * Checks for both "openspec/" and ".openspec/" directory names.
+ */
+export async function detectLegacyToolArtifacts(projectPath) {
+    // Find whichever openspec directory exists (prefer "openspec" over ".openspec")
+    let legacyDirName = OPENSPEC_DIR_CANDIDATES[0];
+    let legacyDirPath = path.join(projectPath, legacyDirName);
+    let hasLegacyDir = false;
+    for (const candidate of OPENSPEC_DIR_CANDIDATES) {
+        const candidatePath = path.join(projectPath, candidate);
+        if (await FileSystemUtils.directoryExists(candidatePath)) {
+            legacyDirName = candidate;
+            legacyDirPath = candidatePath;
+            hasLegacyDir = true;
+            break;
+        }
+    }
+    const legacySkillFiles = [];
+    const legacyCommandFiles = [];
+    // Scan all known tool skill directories for opsx-* skill dirs
+    for (const tool of AI_TOOLS) {
+        if (!tool.skillsDir)
+            continue;
+        const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+        if (await FileSystemUtils.directoryExists(skillsDir)) {
+            try {
+                const entries = await fs.readdir(skillsDir);
+                for (const entry of entries) {
+                    // Match both opsx-* prefixed dirs and any dir containing "openspec"
+                    if (entry.startsWith(OPENSPEC_SKILL_PREFIX) || entry.includes('openspec')) {
+                        legacySkillFiles.push(path.join(tool.skillsDir, 'skills', entry));
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        // Scan for old command files (opsx-*.md or openspec/ dir)
+        const adapter = CommandAdapterRegistry.get(tool.value);
+        if (!adapter)
+            continue;
+        // Check for old opsx-prefixed command files using the adapter's base dir
+        for (const workflow of ALL_WORKFLOWS) {
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            const dir = path.dirname(fullPath);
+            const basename = path.basename(fullPath);
+            // Check for opsx-prefixed variant in the same directory
+            const opsPrefixedName = basename.replace(/^pastel-/, OPENSPEC_COMMAND_PREFIX);
+            if (opsPrefixedName !== basename) {
+                const opsPrefixedPath = path.join(dir, opsPrefixedName);
+                try {
+                    await fs.access(opsPrefixedPath);
+                    const rel = path.relative(projectPath, opsPrefixedPath).replace(/\\/g, '/');
+                    legacyCommandFiles.push(rel);
+                }
+                catch {
+                    // file doesn't exist
+                }
+            }
+        }
+        // Check for old opsx/ and openspec/ command directories (claude/gemini-style)
+        const toolDir = path.join(projectPath, tool.skillsDir);
+        for (const cmdDirName of OPENSPEC_COMMAND_DIRS) {
+            const legacyCmdDir = path.join(toolDir, 'commands', cmdDirName);
+            if (await FileSystemUtils.directoryExists(legacyCmdDir)) {
+                const rel = path.relative(projectPath, legacyCmdDir).replace(/\\/g, '/');
+                legacyCommandFiles.push(rel + '/');
+            }
+        }
+    }
+    const hasLegacyArtifacts = hasLegacyDir ||
+        legacySkillFiles.length > 0 ||
+        legacyCommandFiles.length > 0;
+    return {
+        hasLegacyDir,
+        legacyDirPath,
+        legacyDirName,
+        legacySkillFiles,
+        legacyCommandFiles,
+        hasLegacyArtifacts,
+    };
+}
+// ---------------------------------------------------------------------------
+// Summary display
+// ---------------------------------------------------------------------------
+/**
+ * Formats a human-readable summary of what was detected.
+ * @param pscodeAlreadyExists - when true, shows merge instead of rename
+ */
+export function formatLegacyToolDetectionSummary(detection, pscodeAlreadyExists = false) {
+    const lines = [];
+    lines.push(chalk.bold('This project uses the OpenSpec framework'));
+    lines.push('');
+    lines.push('OpenSpec and Pscode share the same workflow philosophy, but Pscode');
+    lines.push('is the evolution of the framework — with better tooling, more AI integrations,');
+    lines.push('and active development going forward.');
+    lines.push('');
+    lines.push('Migrating will:');
+    lines.push('');
+    if (detection.hasLegacyDir) {
+        const dirName = detection.legacyDirName;
+        if (pscodeAlreadyExists) {
+            lines.push(`  • Merge ${chalk.cyan(dirName + '/changes')} and ${chalk.cyan(dirName + '/specs')} into ${chalk.cyan('pscode/')} — your work stays intact`);
+            lines.push(`  • Remove ${chalk.cyan(dirName + '/')} after merge`);
+        }
+        else {
+            lines.push(`  • Move ${chalk.cyan(dirName + '/')} → ${chalk.cyan('pscode/')} — all your changes and specs come along`);
+        }
+    }
+    if (detection.legacySkillFiles.length > 0) {
+        lines.push(`  • Remove ${detection.legacySkillFiles.length} old opsx-* / openspec-* skill director${detection.legacySkillFiles.length === 1 ? 'y' : 'ies'}`);
+        for (const f of detection.legacySkillFiles) {
+            lines.push(`      ${chalk.dim(f + '/')}`);
+        }
+    }
+    if (detection.legacyCommandFiles.length > 0) {
+        lines.push(`  • Remove ${detection.legacyCommandFiles.length} old opsx/ / openspec/ command folder${detection.legacyCommandFiles.length === 1 ? '' : 's'} and file${detection.legacyCommandFiles.length === 1 ? '' : 's'}`);
+        for (const f of detection.legacyCommandFiles) {
+            lines.push(`      ${chalk.dim(f)}`);
+        }
+    }
+    lines.push('');
+    lines.push(chalk.dim('Fresh Pscode skills and commands will be installed right after.'));
+    return lines.join('\n');
+}
+/**
+ * Formats a summary of what was done during migration.
+ */
+export function formatLegacyToolMigrationSummary(result) {
+    const lines = [];
+    if (result.renamedDir) {
+        lines.push(`  ✓ Renamed ${result.sourceDirName}/ → pscode/`);
+    }
+    if (result.mergedDir) {
+        lines.push(`  ✓ Merged ${result.sourceDirName}/ content into pscode/`);
+        for (const f of result.mergedFiles) {
+            lines.push(`      ${chalk.dim(f)}`);
+        }
+    }
+    for (const f of result.deletedSkills) {
+        lines.push(`  ✓ Deleted skill: ${f}`);
+    }
+    for (const f of result.deletedCommands) {
+        lines.push(`  ✓ Deleted command: ${f}`);
+    }
+    for (const e of result.errors) {
+        lines.push(`  ⚠ ${e}`);
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Migration
+// ---------------------------------------------------------------------------
+/** Subdirectories inside .openspec/ that carry user data worth migrating. */
+const OPENSPEC_DATA_DIRS = ['changes', 'specs'];
+/**
+ * Recursively copies files from `src` into `dst`.
+ * Existing destination files are never overwritten (skip-if-exists strategy).
+ * Returns the list of relative paths (relative to `src`) that were copied.
+ */
+async function mergeDirectoryInto(src, dst, baseRel = '') {
+    const copied = [];
+    let entries;
+    try {
+        entries = await fs.readdir(src, { withFileTypes: true });
+    }
+    catch {
+        return copied; // src doesn't exist or can't be read
+    }
+    await fs.mkdir(dst, { recursive: true });
+    for (const entry of entries) {
+        const rel = baseRel ? `${baseRel}/${entry.name}` : entry.name;
+        const srcPath = path.join(src, entry.name);
+        const dstPath = path.join(dst, entry.name);
+        if (entry.isDirectory()) {
+            const sub = await mergeDirectoryInto(srcPath, dstPath, rel);
+            copied.push(...sub);
+        }
+        else {
+            // Skip if destination already exists
+            const dstExists = await fs.stat(dstPath).then(() => true).catch(() => false);
+            if (!dstExists) {
+                try {
+                    await fs.copyFile(srcPath, dstPath);
+                    copied.push(rel);
+                }
+                catch {
+                    // best-effort
+                }
+            }
+        }
+    }
+    return copied;
+}
+/**
+ * Runs the legacy tool → pscode migration.
+ * - Deletes old opsx-* skill directories
+ * - Deletes old openspec command files/directories
+ * - If pscode/ doesn't exist: renames .openspec/ → pscode/
+ * - If pscode/ already exists: merges changes/ and specs/ from .openspec/
+ *   into pscode/ (existing files are never overwritten), then removes .openspec/
+ */
+export async function runLegacyToolMigration(projectPath, detection) {
+    const result = {
+        renamedDir: false,
+        mergedDir: false,
+        sourceDirName: detection.legacyDirName,
+        deletedSkills: [],
+        deletedCommands: [],
+        mergedFiles: [],
+        errors: [],
+    };
+    // 1. Delete old opsx-* skill directories
+    for (const relPath of detection.legacySkillFiles) {
+        const fullPath = path.join(projectPath, relPath);
+        try {
+            await fs.rm(fullPath, { recursive: true, force: true });
+            result.deletedSkills.push(relPath);
+        }
+        catch (err) {
+            result.errors.push(`Could not delete skill ${relPath}: ${err.message}`);
+        }
+    }
+    // 2. Delete old openspec command files / directories
+    for (const relPath of detection.legacyCommandFiles) {
+        const fullPath = path.join(projectPath, relPath.replace(/\/$/, ''));
+        try {
+            const stat = await fs.stat(fullPath).catch(() => null);
+            if (stat?.isDirectory()) {
+                await fs.rm(fullPath, { recursive: true, force: true });
+            }
+            else if (stat) {
+                await fs.unlink(fullPath);
+            }
+            result.deletedCommands.push(relPath);
+        }
+        catch (err) {
+            result.errors.push(`Could not delete command ${relPath}: ${err.message}`);
+        }
+    }
+    // 3. Migrate .openspec/ directory
+    if (detection.hasLegacyDir) {
+        const pscodePath = path.join(projectPath, 'pscode');
+        const pscodeExists = await FileSystemUtils.directoryExists(pscodePath);
+        if (pscodeExists) {
+            // pscode/ already exists — merge user data subdirectories, then remove .openspec/
+            for (const subDir of OPENSPEC_DATA_DIRS) {
+                const srcSub = path.join(detection.legacyDirPath, subDir);
+                const dstSub = path.join(pscodePath, subDir);
+                const copied = await mergeDirectoryInto(srcSub, dstSub, subDir);
+                result.mergedFiles.push(...copied);
+            }
+            try {
+                await fs.rm(detection.legacyDirPath, { recursive: true, force: true });
+                result.mergedDir = true;
+            }
+            catch (err) {
+                result.errors.push(`Could not remove ${detection.legacyDirName}/ after merge: ${err.message}`);
+            }
+        }
+        else {
+            // pscode/ doesn't exist yet — simple rename
+            try {
+                await fs.rename(detection.legacyDirPath, pscodePath);
+                result.renamedDir = true;
+            }
+            catch (err) {
+                result.errors.push(`Could not rename ${detection.legacyDirName}/ → pscode/: ${err.message}`);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Returns true when a `pscode/` directory already exists at the given project path.
+ * Used by the init command to pass the correct context to formatLegacyToolDetectionSummary.
+ */
+export async function pscodeDirExists(projectPath) {
+    return FileSystemUtils.directoryExists(path.join(projectPath, 'pscode'));
+}
+//# sourceMappingURL=openspec-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,197 @@
+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: 'pscode-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 codeFenceLineMask = ChangeParser.buildCodeFenceMask(lines);
+        const sections = [];
+        const stack = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (codeFenceLineMask[i]) {
+                continue;
+            }
+            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headerMatch) {
+                const level = headerMatch[1].length;
+                const title = headerMatch[2].trim();
+                const contentLines = this.getContentUntilNextHeaderFromLines(lines, codeFenceLineMask, 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, codeFenceLineMask, startLine, currentLevel) {
+        const contentLines = [];
+        for (let i = startLine; i < lines.length; i++) {
+            const line = lines[i];
+            const headerMatch = codeFenceLineMask[i] ? null : 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,26 @@
+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 codeFenceLineMask;
+    private currentLine;
+    constructor(content: string);
+    protected static normalizeContent(content: string): string;
+    protected static buildCodeFenceMask(lines: string[]): boolean[];
+    private static getFenceMarker;
+    private static isClosingFence;
+    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