@dedesfr/prompter 0.8.23 → 1.0.0

package/src/commands/update.ts

@@ -1,156 +0,0 @@
-import chalk from 'chalk';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { PrompterConfig, AVAILABLE_PROMPTS, PROMPTER_DIR } from '../core/config.js';
-import { registry } from '../core/configurators/slash/index.js';
-import { PROMPT_TEMPLATES } from '../core/prompt-templates.js';
-import { discoverSkills } from '../core/skill-discovery.js';
-
-export class UpdateCommand {
-    async execute(): Promise<void> {
-        const projectPath = process.cwd();
-
-        console.log(chalk.blue('\n🔄 Updating Prompter workflow files...\n'));
-
-        // Check if initialized
-        if (!await PrompterConfig.prompterDirExists(projectPath)) {
-            console.log(chalk.red('❌ Prompter is not initialized in this project.'));
-            console.log(chalk.gray('   Run `prompter init` first.\n'));
-            process.exitCode = 1;
-            return;
-        }
-
-        // Detect configured tools
-        const configuredTools = await this.detectConfiguredTools(projectPath);
-
-        if (configuredTools.length === 0) {
-            console.log(chalk.yellow('⚠️  No configured tools found.'));
-            console.log(chalk.gray('   Run `prompter init` to configure tools.\n'));
-            process.exitCode = 1;
-            return;
-        }
-
-        let updatedCount = 0;
-
-        // Update existing workflow files for configured tools only
-        for (const toolId of configuredTools) {
-            const configurator = registry.get(toolId);
-            if (!configurator) continue;
-
-            try {
-                // Only update existing files, don't create new ones
-                const updatedFiles = await configurator.updateExisting(projectPath);
-                for (const file of updatedFiles) {
-                    console.log(chalk.green('✓') + ` Updated ${chalk.cyan(file)}`);
-                    updatedCount++;
-                }
-            } catch (error) {
-                console.log(chalk.red('✗') + ` Failed to update ${configurator.toolId}: ${error}`);
-            }
-        }
-
-        // Update existing prompts in prompter/core/
-        const prompterPath = path.join(projectPath, PROMPTER_DIR);
-        const updatedCorePrompts = await this.updateCorePrompts(prompterPath);
-        for (const promptName of updatedCorePrompts) {
-            console.log(chalk.green('✓') + ` Updated ${chalk.cyan(`${PROMPTER_DIR}/core/${promptName}`)}`);
-            updatedCount++;
-        }
-
-        // Update existing skill workflow files
-        const skillsDir = path.join(projectPath, 'skills');
-        const availableSkills = await discoverSkills(skillsDir);
-
-        if (availableSkills.length > 0) {
-            for (const toolId of configuredTools) {
-                const configurator = registry.get(toolId);
-                if (!configurator) continue;
-
-                try {
-                    const updatedSkillFiles = await configurator.updateExistingSkills(projectPath, availableSkills);
-                    for (const file of updatedSkillFiles) {
-                        console.log(chalk.green('✓') + ` Updated ${chalk.cyan(file)}`);
-                        updatedCount++;
-                    }
-                } catch (error) {
-                    console.log(chalk.red('✗') + ` Failed to update skills for ${configurator.toolId}: ${error}`);
-                }
-            }
-        }
-
-        if (updatedCount === 0) {
-            console.log(chalk.yellow('⚠️  No workflow files found to update.'));
-            console.log(chalk.gray('   Run `prompter init` to create them.\n'));
-        } else {
-            console.log(chalk.green(`\n✅ ${updatedCount} file(s) updated.\n`));
-        }
-    }
-
-    private async fileExists(filePath: string): Promise<boolean> {
-        try {
-            await fs.access(filePath);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    private async detectConfiguredTools(projectPath: string): Promise<string[]> {
-        const configuredTools: string[] = [];
-        const allConfigurators = registry.getAll();
-
-        for (const configurator of allConfigurators) {
-            const targets = configurator.getTargets();
-            let hasFiles = false;
-
-            for (const target of targets) {
-                const filePath = path.join(projectPath, target.path);
-                if (await this.fileExists(filePath)) {
-                    hasFiles = true;
-                    break;
-                }
-            }
-
-            if (hasFiles) {
-                configuredTools.push(configurator.toolId);
-            }
-        }
-
-        return configuredTools;
-    }
-
-    private async updateCorePrompts(prompterPath: string): Promise<string[]> {
-        const updatedPrompts: string[] = [];
-        const corePath = path.join(prompterPath, 'core');
-
-        // Check if core directory exists
-        if (!await this.fileExists(corePath)) {
-            return updatedPrompts;
-        }
-
-        // Update each existing prompt file
-        for (const prompt of AVAILABLE_PROMPTS) {
-            const promptFilePath = path.join(corePath, prompt.sourceFile);
-            
-            // Only update if file exists
-            if (await this.fileExists(promptFilePath)) {
-                try {
-                    const content = PROMPT_TEMPLATES[prompt.value];
-                    
-                    if (!content) {
-                        console.log(chalk.yellow(`  Warning: Template not found for ${prompt.name}`));
-                        continue;
-                    }
-                    
-                    // Update the prompt file
-                    await fs.writeFile(promptFilePath, content, 'utf-8');
-                    updatedPrompts.push(prompt.sourceFile);
-                } catch (error) {
-                    console.log(chalk.red(`  Error updating ${prompt.name}: ${error}`));
-                }
-            }
-        }
-
-        return updatedPrompts;
-    }
-}

package/src/commands/upgrade.ts

@@ -1,30 +0,0 @@
-import { spawn } from 'child_process';
-import chalk from 'chalk';
-
-export class UpgradeCommand {
-    async execute(): Promise<void> {
-        console.log(chalk.cyan('\n🔄 Upgrading Prompter to the latest version...\n'));
-
-        const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-        
-        const upgrade = spawn(npmCommand, ['install', '-g', '@dedesfr/prompter@latest'], {
-            stdio: 'inherit',
-            shell: true
-        });
-
-        upgrade.on('close', (code) => {
-            if (code === 0) {
-                console.log(chalk.green('\n✓ Prompter has been upgraded successfully!\n'));
-            } else {
-                console.error(chalk.red(`\n✗ Upgrade failed with exit code ${code}\n`));
-                process.exit(code || 1);
-            }
-        });
-
-        upgrade.on('error', (error) => {
-            console.error(chalk.red('\n✗ Failed to run upgrade command:'), error.message);
-            console.log(chalk.yellow('\nPlease run manually: npm install -g @dedesfr/prompter@latest\n'));
-            process.exit(1);
-        });
-    }
-}

package/src/commands/validate.ts

@@ -1,326 +0,0 @@
-import ora from 'ora';
-import path from 'path';
-import { Validator } from '../core/validation/validator.js';
-import { isInteractive, resolveNoInteractive } from '../utils/interactive.js';
-import { getActiveChangeIds, getSpecIds } from '../utils/item-discovery.js';
-import { nearestMatches } from '../utils/match.js';
-
-type ItemType = 'change' | 'spec';
-
-interface ExecuteOptions {
-  all?: boolean;
-  changes?: boolean;
-  specs?: boolean;
-  type?: string;
-  strict?: boolean;
-  json?: boolean;
-  noInteractive?: boolean;
-  interactive?: boolean; // Commander sets this to false when --no-interactive is used
-  concurrency?: string;
-}
-
-interface BulkItemResult {
-  id: string;
-  type: ItemType;
-  valid: boolean;
-  issues: { level: 'ERROR' | 'WARNING' | 'INFO'; path: string; message: string }[];
-  durationMs: number;
-}
-
-export class ValidateCommand {
-  async execute(itemName: string | undefined, options: ExecuteOptions = {}): Promise<void> {
-    const interactive = isInteractive(options);
-
-    // Handle bulk flags first
-    if (options.all || options.changes || options.specs) {
-      await this.runBulkValidation({
-        changes: !!options.all || !!options.changes,
-        specs: !!options.all || !!options.specs,
-      }, { strict: !!options.strict, json: !!options.json, concurrency: options.concurrency, noInteractive: resolveNoInteractive(options) });
-      return;
-    }
-
-    // No item and no flags
-    if (!itemName) {
-      if (interactive) {
-        await this.runInteractiveSelector({ strict: !!options.strict, json: !!options.json, concurrency: options.concurrency });
-        return;
-      }
-      this.printNonInteractiveHint();
-      process.exitCode = 1;
-      return;
-    }
-
-    // Direct item validation with type detection or override
-    const typeOverride = this.normalizeType(options.type);
-    await this.validateDirectItem(itemName, { typeOverride, strict: !!options.strict, json: !!options.json });
-  }
-
-  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 runInteractiveSelector(opts: { strict: boolean; json: boolean; concurrency?: string }): Promise<void> {
-    const { select } = await import('@inquirer/prompts');
-    const choice = await select({
-      message: 'What would you like to validate?',
-      choices: [
-        { name: 'All (changes + specs)', value: 'all' },
-        { name: 'All changes', value: 'changes' },
-        { name: 'All specs', value: 'specs' },
-        { name: 'Pick a specific change or spec', value: 'one' },
-      ],
-    });
-
-    if (choice === 'all') return this.runBulkValidation({ changes: true, specs: true }, opts);
-    if (choice === 'changes') return this.runBulkValidation({ changes: true, specs: false }, opts);
-    if (choice === 'specs') return this.runBulkValidation({ changes: false, specs: true }, opts);
-
-    // one
-    const [changes, specs] = await Promise.all([getActiveChangeIds(), getSpecIds()]);
-    const items: { name: string; value: { type: ItemType; id: string } }[] = [];
-    items.push(...changes.map(id => ({ name: `change/${id}`, value: { type: 'change' as const, id } })));
-    items.push(...specs.map(id => ({ name: `spec/${id}`, value: { type: 'spec' as const, id } })));
-    if (items.length === 0) {
-      console.error('No items found to validate.');
-      process.exitCode = 1;
-      return;
-    }
-    const picked = await select<{ type: ItemType; id: string }>({ message: 'Pick an item', choices: items });
-    await this.validateByType(picked.type, picked.id, opts);
-  }
-
-  private printNonInteractiveHint(): void {
-    console.error('Nothing to validate. Try one of:');
-    console.error('  prompter validate --all');
-    console.error('  prompter validate --changes');
-    console.error('  prompter validate --specs');
-    console.error('  prompter validate <item-name>');
-    console.error('Or run in an interactive terminal.');
-  }
-
-  private async validateDirectItem(itemName: string, opts: { typeOverride?: ItemType; strict: boolean; json: boolean }): Promise<void> {
-    const [changes, specs] = await Promise.all([getActiveChangeIds(), getSpecIds()]);
-    const isChange = changes.includes(itemName);
-    const isSpec = specs.includes(itemName);
-
-    const type = opts.typeOverride ?? (isChange ? 'change' : isSpec ? 'spec' : undefined);
-
-    if (!type) {
-      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 (!opts.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 validate / prompter spec validate');
-      process.exitCode = 1;
-      return;
-    }
-
-    await this.validateByType(type, itemName, opts);
-  }
-
-  private async validateByType(type: ItemType, id: string, opts: { strict: boolean; json: boolean }): Promise<void> {
-    const validator = new Validator(opts.strict);
-    if (type === 'change') {
-      const changeDir = path.join(process.cwd(), 'prompter', 'changes', id);
-      const start = Date.now();
-      const report = await validator.validateChangeDeltaSpecs(changeDir);
-      const durationMs = Date.now() - start;
-      this.printReport('change', id, report, durationMs, opts.json);
-      // Non-zero exit if invalid (keeps enriched output test semantics)
-      process.exitCode = report.valid ? 0 : 1;
-      return;
-    }
-    const file = path.join(process.cwd(), 'prompter', 'specs', id, 'spec.md');
-    const start = Date.now();
-    const report = await validator.validateSpec(file);
-    const durationMs = Date.now() - start;
-    this.printReport('spec', id, report, durationMs, opts.json);
-    process.exitCode = report.valid ? 0 : 1;
-  }
-
-  private printReport(type: ItemType, id: string, report: { valid: boolean; issues: any[] }, durationMs: number, json: boolean): void {
-    if (json) {
-      const out = { items: [{ id, type, valid: report.valid, issues: report.issues, durationMs }], summary: { totals: { items: 1, passed: report.valid ? 1 : 0, failed: report.valid ? 0 : 1 }, byType: { [type]: { items: 1, passed: report.valid ? 1 : 0, failed: report.valid ? 0 : 1 } } }, version: '1.0' };
-      console.log(JSON.stringify(out, null, 2));
-      return;
-    }
-    if (report.valid) {
-      console.log(`${type === 'change' ? 'Change' : 'Specification'} '${id}' is valid`);
-    } else {
-      console.error(`${type === 'change' ? 'Change' : 'Specification'} '${id}' has issues`);
-      for (const issue of report.issues) {
-        const label = issue.level === 'ERROR' ? 'ERROR' : issue.level;
-        const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
-        console.error(`${prefix} [${label}] ${issue.path}: ${issue.message}`);
-      }
-      this.printNextSteps(type);
-    }
-  }
-
-  private printNextSteps(type: ItemType): void {
-    const bullets: string[] = [];
-    if (type === 'change') {
-      bullets.push('- Ensure change has deltas in specs/: use headers ## ADDED/MODIFIED/REMOVED/RENAMED Requirements');
-      bullets.push('- Each requirement MUST include at least one #### Scenario: block');
-      bullets.push('- Debug parsed deltas: prompter change show <id> --json --deltas-only');
-    } else {
-      bullets.push('- Ensure spec includes ## Purpose and ## Requirements sections');
-      bullets.push('- Each requirement MUST include at least one #### Scenario: block');
-      bullets.push('- Re-run with --json to see structured report');
-    }
-    console.error('Next steps:');
-    bullets.forEach(b => console.error(`  ${b}`));
-  }
-
-  private async runBulkValidation(scope: { changes: boolean; specs: boolean }, opts: { strict: boolean; json: boolean; concurrency?: string; noInteractive?: boolean }): Promise<void> {
-    const spinner = !opts.json && !opts.noInteractive ? ora('Validating...').start() : undefined;
-    const [changeIds, specIds] = await Promise.all([
-      scope.changes ? getActiveChangeIds() : Promise.resolve<string[]>([]),
-      scope.specs ? getSpecIds() : Promise.resolve<string[]>([]),
-    ]);
-
-    const DEFAULT_CONCURRENCY = 6;
-    const maxSuggestions = 5; // used by nearestMatches
-    const concurrency = normalizeConcurrency(opts.concurrency) ?? normalizeConcurrency(process.env.PROMPTER_CONCURRENCY) ?? DEFAULT_CONCURRENCY;
-    const validator = new Validator(opts.strict);
-    const queue: Array<() => Promise<BulkItemResult>> = [];
-
-    for (const id of changeIds) {
-      queue.push(async () => {
-        const start = Date.now();
-        const changeDir = path.join(process.cwd(), 'prompter', 'changes', id);
-        const report = await validator.validateChangeDeltaSpecs(changeDir);
-        const durationMs = Date.now() - start;
-        return { id, type: 'change' as const, valid: report.valid, issues: report.issues, durationMs };
-      });
-    }
-    for (const id of specIds) {
-      queue.push(async () => {
-        const start = Date.now();
-        const file = path.join(process.cwd(), 'prompter', 'specs', id, 'spec.md');
-        const report = await validator.validateSpec(file);
-        const durationMs = Date.now() - start;
-        return { id, type: 'spec' as const, valid: report.valid, issues: report.issues, durationMs };
-      });
-    }
-
-    if (queue.length === 0) {
-      spinner?.stop();
-
-      const summary = {
-        totals: { items: 0, passed: 0, failed: 0 },
-        byType: {
-          ...(scope.changes ? { change: { items: 0, passed: 0, failed: 0 } } : {}),
-          ...(scope.specs ? { spec: { items: 0, passed: 0, failed: 0 } } : {}),
-        },
-      } as const;
-
-      if (opts.json) {
-        const out = { items: [] as BulkItemResult[], summary, version: '1.0' };
-        console.log(JSON.stringify(out, null, 2));
-      } else {
-        console.log('No items found to validate.');
-      }
-
-      process.exitCode = 0;
-      return;
-    }
-
-    const results: BulkItemResult[] = [];
-    let index = 0;
-    let running = 0;
-    let passed = 0;
-    let failed = 0;
-
-    await new Promise<void>((resolve) => {
-      const next = () => {
-        while (running < concurrency && index < queue.length) {
-          const currentIndex = index++;
-          const task = queue[currentIndex];
-          running++;
-          if (spinner) spinner.text = `Validating (${currentIndex + 1}/${queue.length})...`;
-          task()
-            .then(res => {
-              results.push(res);
-              if (res.valid) passed++; else failed++;
-            })
-            .catch((error: any) => {
-              const message = error?.message || 'Unknown error';
-              const res: BulkItemResult = { id: getPlannedId(currentIndex, changeIds, specIds) ?? 'unknown', type: getPlannedType(currentIndex, changeIds, specIds) ?? 'change', valid: false, issues: [{ level: 'ERROR', path: 'file', message }], durationMs: 0 };
-              results.push(res);
-              failed++;
-            })
-            .finally(() => {
-              running--;
-              if (index >= queue.length && running === 0) resolve();
-              else next();
-            });
-        }
-      };
-      next();
-    });
-
-    spinner?.stop();
-
-    results.sort((a, b) => a.id.localeCompare(b.id));
-    const summary = {
-      totals: { items: results.length, passed, failed },
-      byType: {
-        ...(scope.changes ? { change: summarizeType(results, 'change') } : {}),
-        ...(scope.specs ? { spec: summarizeType(results, 'spec') } : {}),
-      },
-    } as const;
-
-    if (opts.json) {
-      const out = { items: results, summary, version: '1.0' };
-      console.log(JSON.stringify(out, null, 2));
-    } else {
-      for (const res of results) {
-        if (res.valid) console.log(`✓ ${res.type}/${res.id}`);
-        else console.error(`✗ ${res.type}/${res.id}`);
-      }
-      console.log(`Totals: ${summary.totals.passed} passed, ${summary.totals.failed} failed (${summary.totals.items} items)`);
-    }
-
-    process.exitCode = failed > 0 ? 1 : 0;
-  }
-}
-
-function summarizeType(results: BulkItemResult[], type: ItemType) {
-  const filtered = results.filter(r => r.type === type);
-  const items = filtered.length;
-  const passed = filtered.filter(r => r.valid).length;
-  const failed = items - passed;
-  return { items, passed, failed };
-}
-
-function normalizeConcurrency(value?: string): number | undefined {
-  if (!value) return undefined;
-  const n = parseInt(value, 10);
-  if (Number.isNaN(n) || n <= 0) return undefined;
-  return n;
-}
-
-function getPlannedId(index: number, changeIds: string[], specIds: string[]): string | undefined {
-  const totalChanges = changeIds.length;
-  if (index < totalChanges) return changeIds[index];
-  const specIndex = index - totalChanges;
-  return specIds[specIndex];
-}
-
-function getPlannedType(index: number, changeIds: string[], specIds: string[]): ItemType | undefined {
-  const totalChanges = changeIds.length;
-  if (index < totalChanges) return 'change';
-  const specIndex = index - totalChanges;
-  if (specIndex >= 0 && specIndex < specIds.length) return 'spec';
-  return undefined;
-}

package/src/core/artifact-graph/graph.ts

@@ -1,167 +0,0 @@
-import type { Artifact, SchemaYaml, CompletedSet, BlockedArtifacts } from './types.js';
-import { loadSchema, parseSchema } from './schema.js';
-
-/**
- * Represents an artifact dependency graph.
- * Provides methods for querying build order, ready artifacts, and completion status.
- */
-export class ArtifactGraph {
-  private artifacts: Map<string, Artifact>;
-  private schema: SchemaYaml;
-
-  private constructor(schema: SchemaYaml) {
-    this.schema = schema;
-    this.artifacts = new Map(schema.artifacts.map(a => [a.id, a]));
-  }
-
-  /**
-   * Creates an ArtifactGraph from a YAML file path.
-   */
-  static fromYaml(filePath: string): ArtifactGraph {
-    const schema = loadSchema(filePath);
-    return new ArtifactGraph(schema);
-  }
-
-  /**
-   * Creates an ArtifactGraph from YAML content string.
-   */
-  static fromYamlContent(yamlContent: string): ArtifactGraph {
-    const schema = parseSchema(yamlContent);
-    return new ArtifactGraph(schema);
-  }
-
-  /**
-   * Creates an ArtifactGraph from a pre-validated schema object.
-   */
-  static fromSchema(schema: SchemaYaml): ArtifactGraph {
-    return new ArtifactGraph(schema);
-  }
-
-  /**
-   * Gets a single artifact by ID.
-   */
-  getArtifact(id: string): Artifact | undefined {
-    return this.artifacts.get(id);
-  }
-
-  /**
-   * Gets all artifacts in the graph.
-   */
-  getAllArtifacts(): Artifact[] {
-    return Array.from(this.artifacts.values());
-  }
-
-  /**
-   * Gets the schema name.
-   */
-  getName(): string {
-    return this.schema.name;
-  }
-
-  /**
-   * Gets the schema version.
-   */
-  getVersion(): number {
-    return this.schema.version;
-  }
-
-  /**
-   * Computes the topological build order using Kahn's algorithm.
-   * Returns artifact IDs in the order they should be built.
-   */
-  getBuildOrder(): string[] {
-    const inDegree = new Map<string, number>();
-    const dependents = new Map<string, string[]>();
-
-    // Initialize all artifacts
-    for (const artifact of this.artifacts.values()) {
-      inDegree.set(artifact.id, artifact.requires.length);
-      dependents.set(artifact.id, []);
-    }
-
-    // Build reverse adjacency (who depends on whom)
-    for (const artifact of this.artifacts.values()) {
-      for (const req of artifact.requires) {
-        dependents.get(req)!.push(artifact.id);
-      }
-    }
-
-    // Start with roots (in-degree 0), sorted for determinism
-    const queue = [...this.artifacts.keys()]
-      .filter(id => inDegree.get(id) === 0)
-      .sort();
-
-    const result: string[] = [];
-
-    while (queue.length > 0) {
-      const current = queue.shift()!;
-      result.push(current);
-
-      // Collect newly ready artifacts, then sort before adding
-      const newlyReady: string[] = [];
-      for (const dep of dependents.get(current)!) {
-        const newDegree = inDegree.get(dep)! - 1;
-        inDegree.set(dep, newDegree);
-        if (newDegree === 0) {
-          newlyReady.push(dep);
-        }
-      }
-      queue.push(...newlyReady.sort());
-    }
-
-    return result;
-  }
-
-  /**
-   * Gets artifacts that are ready to be created (all dependencies completed).
-   */
-  getNextArtifacts(completed: CompletedSet): string[] {
-    const ready: string[] = [];
-
-    for (const artifact of this.artifacts.values()) {
-      if (completed.has(artifact.id)) {
-        continue; // Already completed
-      }
-
-      const allDepsCompleted = artifact.requires.every(req => completed.has(req));
-      if (allDepsCompleted) {
-        ready.push(artifact.id);
-      }
-    }
-
-    // Sort for deterministic ordering
-    return ready.sort();
-  }
-
-  /**
-   * Checks if all artifacts in the graph are completed.
-   */
-  isComplete(completed: CompletedSet): boolean {
-    for (const artifact of this.artifacts.values()) {
-      if (!completed.has(artifact.id)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Gets blocked artifacts and their unmet dependencies.
-   */
-  getBlocked(completed: CompletedSet): BlockedArtifacts {
-    const blocked: BlockedArtifacts = {};
-
-    for (const artifact of this.artifacts.values()) {
-      if (completed.has(artifact.id)) {
-        continue; // Already completed
-      }
-
-      const unmetDeps = artifact.requires.filter(req => !completed.has(req));
-      if (unmetDeps.length > 0) {
-        blocked[artifact.id] = unmetDeps.sort();
-      }
-    }
-
-    return blocked;
-  }
-}