@dedesfr/prompter 0.8.23 → 1.0.0

package/src/commands/list.ts

@@ -1,194 +0,0 @@
-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 '../core/parsers/markdown-parser.js';
-
-interface ChangeInfo {
-  name: string;
-  completedTasks: number;
-  totalTasks: number;
-  lastModified: Date;
-}
-
-interface ListOptions {
-  sort?: 'recent' | 'name';
-  json?: boolean;
-}
-
-/**
- * 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;
-        }
-      }
-    }
-  }
-
-  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: 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';
-  }
-}
-
-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;
-    }
-
-    // specs mode
-    const specsDir = path.join(targetPath, 'prompter', '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;
-    }
-
-    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

@@ -1,138 +0,0 @@
-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;
-  }
-}

package/src/commands/spec.ts

@@ -1,251 +0,0 @@
-import { program } from 'commander';
-import { existsSync, readdirSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { MarkdownParser } from '../core/parsers/markdown-parser.js';
-import { Validator } from '../core/validation/validator.js';
-import type { Spec } from '../core/schemas/index.js';
-import { isInteractive } from '../utils/interactive.js';
-import { getSpecIds } from '../utils/item-discovery.js';
-
-const SPECS_DIR = 'prompter/specs';
-
-interface ShowOptions {
-  json?: boolean;
-  // JSON-only filters (raw-first text has no filters)
-  requirements?: boolean;
-  scenarios?: boolean; // --no-scenarios sets this to false (JSON only)
-  requirement?: string; // JSON only
-  noInteractive?: boolean;
-}
-
-function parseSpecFromFile(specPath: string, specId: string): Spec {
-  const content = readFileSync(specPath, 'utf-8');
-  const parser = new MarkdownParser(content);
-  return parser.parseSpec(specId);
-}
-
-function validateRequirementIndex(spec: Spec, requirementOpt?: string): number | undefined {
-  if (!requirementOpt) return undefined;
-  const index = Number.parseInt(requirementOpt, 10);
-  if (!Number.isInteger(index) || index < 1 || index > spec.requirements.length) {
-    throw new Error(`Requirement ${requirementOpt} not found`);
-  }
-  return index - 1; // convert to 0-based
-}
-
-function filterSpec(spec: Spec, options: ShowOptions): Spec {
-  const requirementIndex = validateRequirementIndex(spec, options.requirement);
-  const includeScenarios = options.scenarios !== false && !options.requirements;
-
-  const filteredRequirements = (requirementIndex !== undefined
-    ? [spec.requirements[requirementIndex]]
-    : spec.requirements
-  ).map(req => ({
-    text: req.text,
-    scenarios: includeScenarios ? req.scenarios : [],
-  }));
-
-  const metadata = spec.metadata ?? { version: '1.0.0', format: 'prompter' as const };
-
-  return {
-    name: spec.name,
-    overview: spec.overview,
-    requirements: filteredRequirements,
-    metadata,
-  };
-}
-
-/**
- * Print the raw markdown content for a spec file without any formatting.
- * Raw-first behavior ensures text mode is a passthrough for deterministic output.
- */
-function printSpecTextRaw(specPath: string): void {
-  const content = readFileSync(specPath, 'utf-8');
-  console.log(content);
-}
-
-export class SpecCommand {
-  private SPECS_DIR = 'prompter/specs';
-
-  async show(specId?: string, options: ShowOptions = {}): Promise<void> {
-    if (!specId) {
-      const canPrompt = isInteractive(options);
-      const specIds = await getSpecIds();
-      if (canPrompt && specIds.length > 0) {
-        const { select } = await import('@inquirer/prompts');
-        specId = await select({
-          message: 'Select a spec to show',
-          choices: specIds.map(id => ({ name: id, value: id })),
-        });
-      } else {
-        throw new Error('Missing required argument <spec-id>');
-      }
-    }
-
-    const specPath = join(this.SPECS_DIR, specId, 'spec.md');
-    if (!existsSync(specPath)) {
-      throw new Error(`Spec '${specId}' not found at prompter/specs/${specId}/spec.md`);
-    }
-
-    if (options.json) {
-      if (options.requirements && options.requirement) {
-        throw new Error('Options --requirements and --requirement cannot be used together');
-      }
-      const parsed = parseSpecFromFile(specPath, specId);
-      const filtered = filterSpec(parsed, options);
-      const output = {
-        id: specId,
-        title: parsed.name,
-        overview: parsed.overview,
-        requirementCount: filtered.requirements.length,
-        requirements: filtered.requirements,
-        metadata: parsed.metadata ?? { version: '1.0.0', format: 'prompter' as const },
-      };
-      console.log(JSON.stringify(output, null, 2));
-      return;
-    }
-    printSpecTextRaw(specPath);
-  }
-}
-
-export function registerSpecCommand(rootProgram: typeof program) {
-  const specCommand = rootProgram
-    .command('spec')
-    .description('Manage and view Prompter specifications');
-
-  // Deprecation notice for noun-based commands
-  specCommand.hook('preAction', () => {
-    console.error('Warning: The "prompter spec ..." commands are deprecated. Prefer verb-first commands (e.g., "prompter show", "prompter validate --specs").');
-  });
-
-  specCommand
-    .command('show [spec-id]')
-    .description('Display a specific specification')
-    .option('--json', 'Output as JSON')
-    .option('--requirements', 'JSON only: Show only requirements (exclude scenarios)')
-    .option('--no-scenarios', 'JSON only: Exclude scenario content')
-    .option('-r, --requirement <id>', 'JSON only: Show specific requirement by ID (1-based)')
-    .option('--no-interactive', 'Disable interactive prompts')
-    .action(async (specId: string | undefined, options: ShowOptions & { noInteractive?: boolean }) => {
-      try {
-        const cmd = new SpecCommand();
-        await cmd.show(specId, options as any);
-      } catch (error) {
-        console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        process.exitCode = 1;
-      }
-    });
-
-  specCommand
-    .command('list')
-    .description('List all available specifications')
-    .option('--json', 'Output as JSON')
-    .option('--long', 'Show id and title with counts')
-    .action((options: { json?: boolean; long?: boolean }) => {
-      try {
-        if (!existsSync(SPECS_DIR)) {
-          console.log('No items found');
-          return;
-        }
-
-        const specs = readdirSync(SPECS_DIR, { withFileTypes: true })
-          .filter(dirent => dirent.isDirectory())
-          .map(dirent => {
-            const specPath = join(SPECS_DIR, dirent.name, 'spec.md');
-            if (existsSync(specPath)) {
-              try {
-                const spec = parseSpecFromFile(specPath, dirent.name);
-                
-                return {
-                  id: dirent.name,
-                  title: spec.name,
-                  requirementCount: spec.requirements.length
-                };
-              } catch {
-                return {
-                  id: dirent.name,
-                  title: dirent.name,
-                  requirementCount: 0
-                };
-              }
-            }
-            return null;
-          })
-          .filter((spec): spec is { id: string; title: string; requirementCount: number } => spec !== null)
-          .sort((a, b) => a.id.localeCompare(b.id));
-
-        if (options.json) {
-          console.log(JSON.stringify(specs, null, 2));
-        } else {
-          if (specs.length === 0) {
-            console.log('No items found');
-            return;
-          }
-          if (!options.long) {
-            specs.forEach(spec => console.log(spec.id));
-            return;
-          }
-          specs.forEach(spec => {
-            console.log(`${spec.id}: ${spec.title} [requirements ${spec.requirementCount}]`);
-          });
-        }
-      } catch (error) {
-        console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        process.exitCode = 1;
-      }
-    });
-
-  specCommand
-    .command('validate [spec-id]')
-    .description('Validate a specification structure')
-    .option('--strict', 'Enable strict validation mode')
-    .option('--json', 'Output validation report as JSON')
-    .option('--no-interactive', 'Disable interactive prompts')
-    .action(async (specId: string | undefined, options: { strict?: boolean; json?: boolean; noInteractive?: boolean }) => {
-      try {
-        if (!specId) {
-          const canPrompt = isInteractive(options);
-          const specIds = await getSpecIds();
-          if (canPrompt && specIds.length > 0) {
-            const { select } = await import('@inquirer/prompts');
-            specId = await select({
-              message: 'Select a spec to validate',
-              choices: specIds.map(id => ({ name: id, value: id })),
-            });
-          } else {
-            throw new Error('Missing required argument <spec-id>');
-          }
-        }
-
-        const specPath = join(SPECS_DIR, specId, 'spec.md');
-        
-        if (!existsSync(specPath)) {
-          throw new Error(`Spec '${specId}' not found at prompter/specs/${specId}/spec.md`);
-        }
-
-        const validator = new Validator(options.strict);
-        const report = await validator.validateSpec(specPath);
-
-        if (options.json) {
-          console.log(JSON.stringify(report, null, 2));
-        } else {
-          if (report.valid) {
-            console.log(`Specification '${specId}' is valid`);
-          } else {
-            console.error(`Specification '${specId}' has issues`);
-            report.issues.forEach(issue => {
-              const label = issue.level === 'ERROR' ? 'ERROR' : issue.level;
-              const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
-              console.error(`${prefix} [${label}] ${issue.path}: ${issue.message}`);
-            });
-          }
-        }
-        process.exitCode = report.valid ? 0 : 1;
-      } catch (error) {
-        console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        process.exitCode = 1;
-      }
-    });
-
-  return specCommand;
-}