@thiagodiogo/pscode 1.0.0

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, 'pscode', 'changes');
+            // Check if changes directory exists
+            try {
+                await fs.access(changesDir);
+            }
+            catch {
+                throw new Error("No Pscode changes directory found. Run 'pscode 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, 'pscode', '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: /ps:propose. Try 'pscode config profile core' for the streamlined experience.");
+}
+//# sourceMappingURL=migration.js.map

package/dist/core/openspec-migration.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+export interface LegacyToolDetectionResult {
+    /** Whether an openspec/ or .openspec/ directory was found */
+    hasLegacyDir: boolean;
+    /** Full path to the openspec/ (or .openspec/) directory that was found */
+    legacyDirPath: string;
+    /** Directory name as it appears on disk ("openspec" or ".openspec") */
+    legacyDirName: string;
+    /** Old opsx-* skill files found across all tool dirs */
+    legacySkillFiles: string[];
+    /** Old opsx-* / openspec command files found across all tool dirs */
+    legacyCommandFiles: string[];
+    /** Whether any legacy tool artifacts were found */
+    hasLegacyArtifacts: boolean;
+}
+export interface LegacyToolMigrationResult {
+    /** Whether openspec/ (or .openspec/) was renamed to pscode/ */
+    renamedDir: boolean;
+    /** Whether openspec/ (or .openspec/) content was merged into an existing pscode/ */
+    mergedDir: boolean;
+    /** The directory name that was migrated ("openspec" or ".openspec") */
+    sourceDirName: string;
+    /** Skill files deleted */
+    deletedSkills: string[];
+    /** Command files/dirs deleted */
+    deletedCommands: string[];
+    /** Files copied during merge (relative to project root) */
+    mergedFiles: string[];
+    /** Errors that occurred */
+    errors: string[];
+}
+/**
+ * Detects legacy tool artifacts in a project.
+ * Checks for both "openspec/" and ".openspec/" directory names.
+ */
+export declare function detectLegacyToolArtifacts(projectPath: string): Promise<LegacyToolDetectionResult>;
+/**
+ * Formats a human-readable summary of what was detected.
+ * @param pscodeAlreadyExists - when true, shows merge instead of rename
+ */
+export declare function formatLegacyToolDetectionSummary(detection: LegacyToolDetectionResult, pscodeAlreadyExists?: boolean): string;
+/**
+ * Formats a summary of what was done during migration.
+ */
+export declare function formatLegacyToolMigrationSummary(result: LegacyToolMigrationResult): string;
+/**
+ * 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 declare function runLegacyToolMigration(projectPath: string, detection: LegacyToolDetectionResult): Promise<LegacyToolMigrationResult>;
+/**
+ * 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 declare function pscodeDirExists(projectPath: string): Promise<boolean>;
+//# sourceMappingURL=openspec-migration.d.ts.map