@dedesfr/prompter 0.6.15 → 0.7.1

package/src/commands/config.ts

@@ -0,0 +1,233 @@
+import { Command } from 'commander';
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import {
+  getGlobalConfigPath,
+  getGlobalConfig,
+  saveGlobalConfig,
+  GlobalConfig,
+} from '../core/global-config.js';
+import {
+  getNestedValue,
+  setNestedValue,
+  deleteNestedValue,
+  coerceValue,
+  formatValueYaml,
+  validateConfigKeyPath,
+  validateConfig,
+  DEFAULT_CONFIG,
+} from '../core/config-schema.js';
+
+/**
+ * Register the config command and all its subcommands.
+ *
+ * @param program - The Commander program instance
+ */
+export function registerConfigCommand(program: Command): void {
+  const configCmd = program
+    .command('config')
+    .description('View and modify global Prompter configuration')
+    .option('--scope <scope>', 'Config scope (only "global" supported currently)')
+    .hook('preAction', (thisCommand) => {
+      const opts = thisCommand.opts();
+      if (opts.scope && opts.scope !== 'global') {
+        console.error('Error: Project-local config is not yet implemented');
+        process.exit(1);
+      }
+    });
+
+  // config path
+  configCmd
+    .command('path')
+    .description('Show config file location')
+    .action(() => {
+      console.log(getGlobalConfigPath());
+    });
+
+  // config list
+  configCmd
+    .command('list')
+    .description('Show all current settings')
+    .option('--json', 'Output as JSON')
+    .action((options: { json?: boolean }) => {
+      const config = getGlobalConfig();
+
+      if (options.json) {
+        console.log(JSON.stringify(config, null, 2));
+      } else {
+        console.log(formatValueYaml(config));
+      }
+    });
+
+  // config get
+  configCmd
+    .command('get <key>')
+    .description('Get a specific value (raw, scriptable)')
+    .action((key: string) => {
+      const config = getGlobalConfig();
+      const value = getNestedValue(config as Record<string, unknown>, key);
+
+      if (value === undefined) {
+        process.exitCode = 1;
+        return;
+      }
+
+      if (typeof value === 'object' && value !== null) {
+        console.log(JSON.stringify(value));
+      } else {
+        console.log(String(value));
+      }
+    });
+
+  // config set
+  configCmd
+    .command('set <key> <value>')
+    .description('Set a value (auto-coerce types)')
+    .option('--string', 'Force value to be stored as string')
+    .option('--allow-unknown', 'Allow setting unknown keys')
+    .action((key: string, value: string, options: { string?: boolean; allowUnknown?: boolean }) => {
+      const allowUnknown = Boolean(options.allowUnknown);
+      const keyValidation = validateConfigKeyPath(key);
+      if (!keyValidation.valid && !allowUnknown) {
+        const reason = keyValidation.reason ? ` ${keyValidation.reason}.` : '';
+        console.error(`Error: Invalid configuration key "${key}".${reason}`);
+        console.error('Use "prompter config list" to see available keys.');
+        console.error('Pass --allow-unknown to bypass this check.');
+        process.exitCode = 1;
+        return;
+      }
+
+      const config = getGlobalConfig() as Record<string, unknown>;
+      const coercedValue = coerceValue(value, options.string || false);
+
+      // Create a copy to validate before saving
+      const newConfig = JSON.parse(JSON.stringify(config));
+      setNestedValue(newConfig, key, coercedValue);
+
+      // Validate the new config
+      const validation = validateConfig(newConfig);
+      if (!validation.success) {
+        console.error(`Error: Invalid configuration - ${validation.error}`);
+        process.exitCode = 1;
+        return;
+      }
+
+      // Apply changes and save
+      setNestedValue(config, key, coercedValue);
+      saveGlobalConfig(config as GlobalConfig);
+
+      const displayValue =
+        typeof coercedValue === 'string' ? `"${coercedValue}"` : String(coercedValue);
+      console.log(`Set ${key} = ${displayValue}`);
+    });
+
+  // config unset
+  configCmd
+    .command('unset <key>')
+    .description('Remove a key (revert to default)')
+    .action((key: string) => {
+      const config = getGlobalConfig() as Record<string, unknown>;
+      const existed = deleteNestedValue(config, key);
+
+      if (existed) {
+        saveGlobalConfig(config as GlobalConfig);
+        console.log(`Unset ${key} (reverted to default)`);
+      } else {
+        console.log(`Key "${key}" was not set`);
+      }
+    });
+
+  // config reset
+  configCmd
+    .command('reset')
+    .description('Reset configuration to defaults')
+    .option('--all', 'Reset all configuration (required)')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .action(async (options: { all?: boolean; yes?: boolean }) => {
+      if (!options.all) {
+        console.error('Error: --all flag is required for reset');
+        console.error('Usage: prompter config reset --all [-y]');
+        process.exitCode = 1;
+        return;
+      }
+
+      if (!options.yes) {
+        const { confirm } = await import('@inquirer/prompts');
+        const confirmed = await confirm({
+          message: 'Reset all configuration to defaults?',
+          default: false,
+        });
+
+        if (!confirmed) {
+          console.log('Reset cancelled.');
+          return;
+        }
+      }
+
+      saveGlobalConfig({ ...DEFAULT_CONFIG });
+      console.log('Configuration reset to defaults');
+    });
+
+  // config edit
+  configCmd
+    .command('edit')
+    .description('Open config in $EDITOR')
+    .action(async () => {
+      const editor = process.env.EDITOR || process.env.VISUAL;
+
+      if (!editor) {
+        console.error('Error: No editor configured');
+        console.error('Set the EDITOR or VISUAL environment variable to your preferred editor');
+        console.error('Example: export EDITOR=vim');
+        process.exitCode = 1;
+        return;
+      }
+
+      const configPath = getGlobalConfigPath();
+
+      // Ensure config file exists with defaults
+      if (!fs.existsSync(configPath)) {
+        saveGlobalConfig({ ...DEFAULT_CONFIG });
+      }
+
+      // Spawn editor and wait for it to close
+      // Avoid shell parsing to correctly handle paths with spaces in both
+      // the editor path and config path
+      const child = spawn(editor, [configPath], {
+        stdio: 'inherit',
+        shell: false,
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        child.on('close', (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`Editor exited with code ${code}`));
+          }
+        });
+        child.on('error', reject);
+      });
+
+      try {
+        const rawConfig = fs.readFileSync(configPath, 'utf-8');
+        const parsedConfig = JSON.parse(rawConfig);
+        const validation = validateConfig(parsedConfig);
+
+        if (!validation.success) {
+          console.error(`Error: Invalid configuration - ${validation.error}`);
+          process.exitCode = 1;
+        }
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+          console.error(`Error: Config file not found at ${configPath}`);
+        } else if (error instanceof SyntaxError) {
+          console.error(`Error: Invalid JSON in ${configPath}`);
+          console.error(error.message);
+        } else {
+          console.error(`Error: Unable to validate configuration - ${error instanceof Error ? error.message : String(error)}`);
+        }
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/init.ts

@@ -120,18 +120,32 @@ export class InitCommand {
         const projectMdPath = path.join(prompterPath, 'project.md');
         const projectMdExists = await this.fileExists(projectMdPath);
         if (!projectMdExists) {
-            await fs.writeFile(projectMdPath, projectTemplate, 'utf-8');
-            console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/project.md')}`);
+            try {
+                if (!projectTemplate) {
+                    throw new Error('project.md template is undefined');
+                }
+                await fs.writeFile(projectMdPath, projectTemplate, 'utf-8');
+                console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/project.md')}`);
+            } catch (error) {
+                console.error(chalk.red('✗') + ` Failed to create project.md: ${error}`);
+            }
         } else if (isReInitialization) {
             console.log(chalk.gray('  project.md already exists, keeping it'));
         }
 
         // Create AGENTS.md for universal support
-        const agentsMdPath = path.join(projectPath, 'AGENTS.md');
+        const agentsMdPath = path.join(prompterPath, 'AGENTS.md');
         const agentsExists = await this.fileExists(agentsMdPath);
         if (!agentsExists) {
-            await fs.writeFile(agentsMdPath, agentsTemplate, 'utf-8');
-            console.log(chalk.green('✓') + ` Created ${chalk.cyan('AGENTS.md')}`);
+            try {
+                if (!agentsTemplate) {
+                    throw new Error('AGENTS.md template is undefined');
+                }
+                await fs.writeFile(agentsMdPath, agentsTemplate, 'utf-8');
+                console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/AGENTS.md')}`);
+            } catch (error) {
+                console.error(chalk.red('✗') + ` Failed to create AGENTS.md: ${error}`);
+            }
         } else {
             console.log(chalk.gray('  AGENTS.md already exists, skipping'));
         }

package/src/commands/list.ts

@@ -1,84 +1,194 @@
 import { promises as fs } from 'fs';
 import path from 'path';
-import chalk from 'chalk';
-import { PROMPTER_DIR, PrompterConfig } from '../core/config.js';
-
-interface ListOptions {
-    json?: boolean;
+import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { MarkdownParser } from '../core/parsers/markdown-parser.js';
+
+interface ChangeInfo {
+  name: string;
+  completedTasks: number;
+  totalTasks: number;
+  lastModified: Date;
 }
 
-interface EnhancedPrompt {
-    id: string;
-    path: string;
-    createdAt?: string;
+interface ListOptions {
+  sort?: 'recent' | 'name';
+  json?: boolean;
 }
 
-export class ListCommand {
-    async execute(options: ListOptions = {}): Promise<void> {
-        const projectPath = process.cwd();
-
-        // Check if initialized
-        if (!await PrompterConfig.prompterDirExists(projectPath)) {
-            if (options.json) {
-                console.log(JSON.stringify({ error: 'Prompter not initialized', prompts: [] }));
-            } else {
-                console.log(chalk.red('❌ Prompter is not initialized in this project.'));
-                console.log(chalk.gray('   Run `prompter init` first.\n'));
-            }
-            process.exitCode = 1;
-            return;
+/**
+ * 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: string): Promise<Date> {
+  let latest: Date | null = null;
+
+  async function walk(dir: string): Promise<void> {
+    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;
         }
+      }
+    }
+  }
 
-        const prompterPath = path.join(projectPath, PROMPTER_DIR);
-        const prompts = await this.scanPrompts(prompterPath);
+  await walk(dirPath);
 
-        if (options.json) {
-            console.log(JSON.stringify(prompts, null, 2));
-            return;
-        }
+  // If no files found, use the directory's own modification time
+  if (latest === null) {
+    const dirStat = await fs.stat(dirPath);
+    return dirStat.mtime;
+  }
 
-        if (prompts.length === 0) {
-            console.log(chalk.yellow('\n📭 No enhanced prompts found.\n'));
-            console.log(chalk.gray('Use /prompter-enhance to create one.\n'));
-            return;
-        }
+  return latest;
+}
 
-        console.log(chalk.blue(`\n📋 Enhanced Prompts (${prompts.length}):\n`));
+/**
+ * Format a date as relative time (e.g., "2 hours ago", "3 days ago")
+ */
+function formatRelativeTime(date: Date): string {
+  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';
+  }
+}
 
-        for (const prompt of prompts) {
-            console.log(chalk.green('  •') + ` ${chalk.cyan(prompt.id)}`);
-            console.log(chalk.gray(`    ${prompt.path}`));
+export class ListCommand {
+  async execute(targetPath: string = '.', mode: 'changes' | 'specs' = 'changes', options: ListOptions = {}): Promise<void> {
+    const { sort = 'recent', json = false } = options;
+
+    if (mode === 'changes') {
+      const changesDir = path.join(targetPath, 'prompter', 'changes');
+
+      // Check if changes directory exists
+      try {
+        await fs.access(changesDir);
+      } catch {
+        throw new Error("No Prompter changes directory found. Run 'prompter 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: ChangeInfo[] = [];
+
+      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;
+    }
 
-        console.log();
+    // specs mode
+    const specsDir = path.join(targetPath, 'prompter', 'specs');
+    try {
+      await fs.access(specsDir);
+    } catch {
+      console.log('No specs found.');
+      return;
     }
 
-    private async scanPrompts(prompterPath: string): Promise<EnhancedPrompt[]> {
-        const prompts: EnhancedPrompt[] = [];
-
-        try {
-            const entries = await fs.readdir(prompterPath, { withFileTypes: true });
-
-            for (const entry of entries) {
-                if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
-
-                const enhancedPromptPath = path.join(prompterPath, entry.name, 'enhanced-prompt.md');
-
-                try {
-                    const stats = await fs.stat(enhancedPromptPath);
-                    prompts.push({
-                        id: entry.name,
-                        path: path.join(PROMPTER_DIR, entry.name, 'enhanced-prompt.md'),
-                        createdAt: stats.birthtime.toISOString()
-                    });
-                } catch {
-                    // No enhanced-prompt.md in this directory, skip
-                }
-            }
-        } catch (error) {
-            // Directory doesn't exist or can't be read
-        }
+    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;
+    }
 
-        return prompts.sort((a, b) => a.id.localeCompare(b.id));
+    type SpecInfo = { id: string; requirementCount: number };
+    const specs: SpecInfo[] = [];
+    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}`);
+    }
+  }
+}

package/src/commands/show.ts

@@ -0,0 +1,138 @@
+import path from 'path';
+import { isInteractive } from '../utils/interactive.js';
+import { getActiveChangeIds, getSpecIds } from '../utils/item-discovery.js';
+import { ChangeCommand } from './change.js';
+import { SpecCommand } from './spec.js';
+import { nearestMatches } from '../utils/match.js';
+
+type ItemType = 'change' | 'spec';
+
+const CHANGE_FLAG_KEYS = new Set(['deltasOnly', 'requirementsOnly']);
+const SPEC_FLAG_KEYS = new Set(['requirements', 'scenarios', 'requirement']);
+
+export class ShowCommand {
+  async execute(itemName?: string, options: { json?: boolean; type?: string; noInteractive?: boolean; [k: string]: any } = {}): Promise<void> {
+    const interactive = isInteractive(options);
+    const typeOverride = this.normalizeType(options.type);
+
+    if (!itemName) {
+      if (interactive) {
+        const { select } = await import('@inquirer/prompts');
+        const type = await select<ItemType>({
+          message: 'What would you like to show?',
+          choices: [
+            { name: 'Change', value: 'change' as const },
+            { name: 'Spec', value: 'spec' as const },
+          ],
+        });
+        await this.runInteractiveByType(type, options);
+        return;
+      }
+      this.printNonInteractiveHint();
+      process.exitCode = 1;
+      return;
+    }
+
+    await this.showDirect(itemName, { typeOverride, options });
+  }
+
+  private normalizeType(value?: string): ItemType | undefined {
+    if (!value) return undefined;
+    const v = value.toLowerCase();
+    if (v === 'change' || v === 'spec') return v;
+    return undefined;
+  }
+
+  private async runInteractiveByType(type: ItemType, options: { json?: boolean; noInteractive?: boolean; [k: string]: any }): Promise<void> {
+    const { select } = await import('@inquirer/prompts');
+    if (type === 'change') {
+      const changes = await getActiveChangeIds();
+      if (changes.length === 0) {
+        console.error('No changes found.');
+        process.exitCode = 1;
+        return;
+      }
+      const picked = await select<string>({ message: 'Pick a change', choices: changes.map(id => ({ name: id, value: id })) });
+      const cmd = new ChangeCommand();
+      await cmd.show(picked, options as any);
+      return;
+    }
+
+    const specs = await getSpecIds();
+    if (specs.length === 0) {
+      console.error('No specs found.');
+      process.exitCode = 1;
+      return;
+    }
+    const picked = await select<string>({ message: 'Pick a spec', choices: specs.map(id => ({ name: id, value: id })) });
+    const cmd = new SpecCommand();
+    await cmd.show(picked, options as any);
+  }
+
+  private async showDirect(itemName: string, params: { typeOverride?: ItemType; options: { json?: boolean; [k: string]: any } }): Promise<void> {
+    // Optimize lookups when type is pre-specified
+    let isChange = false;
+    let isSpec = false;
+    let changes: string[] = [];
+    let specs: string[] = [];
+    if (params.typeOverride === 'change') {
+      changes = await getActiveChangeIds();
+      isChange = changes.includes(itemName);
+    } else if (params.typeOverride === 'spec') {
+      specs = await getSpecIds();
+      isSpec = specs.includes(itemName);
+    } else {
+      [changes, specs] = await Promise.all([getActiveChangeIds(), getSpecIds()]);
+      isChange = changes.includes(itemName);
+      isSpec = specs.includes(itemName);
+    }
+
+    const resolvedType = params.typeOverride ?? (isChange ? 'change' : isSpec ? 'spec' : undefined);
+
+    if (!resolvedType) {
+      console.error(`Unknown item '${itemName}'`);
+      const suggestions = nearestMatches(itemName, [...changes, ...specs]);
+      if (suggestions.length) console.error(`Did you mean: ${suggestions.join(', ')}?`);
+      process.exitCode = 1;
+      return;
+    }
+
+    if (!params.typeOverride && isChange && isSpec) {
+      console.error(`Ambiguous item '${itemName}' matches both a change and a spec.`);
+      console.error('Pass --type change|spec, or use: prompter change show / prompter spec show');
+      process.exitCode = 1;
+      return;
+    }
+
+    this.warnIrrelevantFlags(resolvedType, params.options);
+    if (resolvedType === 'change') {
+      const cmd = new ChangeCommand();
+      await cmd.show(itemName, params.options as any);
+      return;
+    }
+    const cmd = new SpecCommand();
+    await cmd.show(itemName, params.options as any);
+  }
+
+  private printNonInteractiveHint(): void {
+    console.error('Nothing to show. Try one of:');
+    console.error('  prompter show <item>');
+    console.error('  prompter change show');
+    console.error('  prompter spec show');
+    console.error('Or run in an interactive terminal.');
+  }
+
+  private warnIrrelevantFlags(type: ItemType, options: { [k: string]: any }): boolean {
+    const irrelevant: string[] = [];
+    if (type === 'change') {
+      for (const k of SPEC_FLAG_KEYS) if (k in options) irrelevant.push(k);
+    } else {
+      for (const k of CHANGE_FLAG_KEYS) if (k in options) irrelevant.push(k);
+    }
+    if (irrelevant.length > 0) {
+      console.error(`Warning: Ignoring flags not applicable to ${type}: ${irrelevant.join(', ')}`);
+      return true;
+    }
+    return false;
+  }
+}