@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/commands/project/standards.js

@@ -1,36 +1,10 @@
-/**
- * `morph-spec standards --find "<query>" [--category <c>] [--tags <a,b>] [--json]`
- *
- * Server-side replacement for "read the whole STANDARDS.json to pick 1-3
- * standards" (R2 of the performance plan — token cut per task). Today
- * morph-implement loads the full 65 KB / 60-entry registry (with a `digest`
- * per entry) just to choose a couple of relevant standards: ~16k tokens per
- * task. This command searches server-side and returns only the TOP 3 hits —
- * `id · path · digest` — where the digest is the FULL text: it is what
- * substitutes for actually reading the standard's .md file.
- *
- * Without `--find` (a bare call): lists categories + counts — a cheap
- * orientation view, no scoring.
- *
- * A query with no hit exits 0 (this is advisory tooling, not a gate) with a
- * human-readable warning + category suggestions on stderr, and — under
- * `--json` — a stable `{ query, results: [], suggestion }` shape on stdout so
- * a JSON consumer never has to special-case "no results" as a parse error.
- */
-
 import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
 import chalk from 'chalk';
+import { loadStandardsRegistry } from '../../lib/standards/registry.js';
+import { markdownHeadings, sectionBySlug } from '../../lib/standards/sections.js';
 
-/**
- * Resolve STANDARDS.json the same way doctor.js resolves the standards root:
- * an installed project first (`.morph/framework/standards/`), falling back
- * to this package's own bundled copy (`framework/standards/`) — the framework
- * repo in dev, or the npm package's own copy before `setup-infra` has run.
- *
- * @param {string} targetPath - project root to look for `.morph/` under
- * @returns {string|null} absolute path to STANDARDS.json, or null if neither exists
- */
+/** Installed project first, else this package's bundled copy (dev repo, or before `setup-infra` ran). */
 export function resolveStandardsJsonPath(targetPath) {
   const installed = join(targetPath, '.morph', 'framework', 'standards', 'STANDARDS.json');
   if (existsSync(installed)) return installed;
@@ -41,17 +15,62 @@ export function resolveStandardsJsonPath(targetPath) {
   return null;
 }
 
-/** Load + parse STANDARDS.json. Throws on missing/invalid file — caller decides how to report it. */
-function loadRegistry(standardsJsonPath) {
-  const raw = readFileSync(standardsJsonPath, 'utf8');
-  return JSON.parse(raw);
+export function resolveStandardSection(standard, mdText, anchor) {
+  if (mdText === null) return { status: 'unreadable' };
+  const anchors = standard.anchors || {};
+  const slug = String(anchors[anchor] ?? anchor).replace(/^#/, '');
+  const section = sectionBySlug(mdText, slug);
+  if (section) return { status: 'ok', section, slug };
+  return { status: 'unknown-anchor', anchors, headings: markdownHeadings(mdText).map((h) => h.slug) };
+}
+
+function readStandardMd(standardsJsonPath, standard) {
+  try {
+    return readFileSync(join(dirname(standardsJsonPath), standard.path), 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function showStandard(standards, standardsJsonPath, target, json) {
+  const hash = String(target).indexOf('#');
+  const id = hash === -1 ? String(target) : String(target).slice(0, hash);
+  const anchor = hash === -1 ? '' : String(target).slice(hash + 1).replace(/^#+/, '');
+  const standard = standards.find((s) => s.id === id);
+  if (!standard) {
+    const near = findStandards(standards, id.replace(/-/g, ' ')).map((s) => s.id);
+    if (json) console.log(JSON.stringify({ id, error: 'unknown-id', suggestions: near }));
+    else console.error(chalk.red(`\n❌ Standard "${id}" não existe.`) + (near.length ? chalk.gray(` Talvez: ${near.join(', ')}`) : '') + '\n');
+    process.exit(1);
+  }
+  const anchors = standard.anchors || {};
+
+  if (!anchor) {
+    if (json) {
+      console.log(JSON.stringify({ id: standard.id, path: standard.path, digest: standard.digest, anchors }));
+      process.exit(0);
+    }
+    console.log(chalk.cyan(`\n${standard.id}`) + chalk.gray(`  (${standard.path})`));
+    console.log(`\n${standard.digest || '(sem digest)'}\n`);
+    console.log(chalk.bold('Âncoras') + chalk.gray(` — morph-spec standards --show ${standard.id}#<âncora>`));
+    for (const [key, slug] of Object.entries(anchors)) console.log(`  ${key.padEnd(16)}${slug}`);
+    console.log('');
+    process.exit(0);
+  }
+
+  const result = resolveStandardSection(standard, readStandardMd(standardsJsonPath, standard), anchor);
+  if (result.status === 'ok') {
+    if (json) console.log(JSON.stringify({ id: standard.id, anchor, slug: result.slug, section: result.section }));
+    else process.stdout.write(result.section);
+    process.exit(0);
+  }
+  if (json) console.log(JSON.stringify({ id: standard.id, anchor, error: result.status, anchors }));
+  else if (result.status === 'unreadable') console.error(chalk.red(`\n❌ ${standard.path} não pôde ser lido.\n`));
+  else console.error(chalk.red(`\n❌ "${anchor}" não é âncora nem heading de ${standard.id}.`)
+    + chalk.gray(` Âncoras: ${Object.keys(anchors).join(', ') || '(nenhuma)'}\n`));
+  process.exit(1);
 }
 
-/**
- * category → count, sorted by count desc then name asc.
- * @param {object[]} standards
- * @returns {{ category: string, count: number }[]}
- */
 export function categoryCounts(standards) {
   const counts = {};
   for (const std of standards) {
@@ -63,16 +82,6 @@ export function categoryCounts(standards) {
     .sort((a, b) => b.count - a.count || a.category.localeCompare(b.category));
 }
 
-/**
- * Simple weighted relevance score for one standard against a query.
- * Tiers, as specified: name/id > tags(+aliases) > digest. category/subcategory
- * ride alongside the tags tier (lighter). A token-level fallback keeps
- * multi-word queries findable even without a verbatim phrase match anywhere.
- *
- * @param {object} std - one STANDARDS.json entry
- * @param {string} query - raw user query (already trimmed, non-empty)
- * @returns {number} score, 0 = no match
- */
 export function scoreStandard(std, query) {
   const q = query.toLowerCase();
   const tokens = q.split(/\s+/).filter((t) => t.length >= 3);
@@ -87,19 +96,15 @@ export function scoreStandard(std, query) {
 
   let score = 0;
 
-  // Tier 1: name / id — the strongest signal.
   if (id === q || name === q) score += 20;
   else if (id.includes(q) || name.includes(q)) score += 12;
 
-  // Tier 2: tags / aliases (curated search terms) + category/subcategory.
   if (tags.includes(q) || aliases.includes(q)) score += 8;
   else if (tags.some((t) => t.includes(q)) || aliases.some((a) => a.includes(q))) score += 5;
   if (category === q || subcategory === q) score += 4;
 
-  // Tier 3: digest — weakest signal, full-phrase substring only.
   if (digest.includes(q)) score += 2;
 
-  // Token-level fallback for multi-word queries with no verbatim match above.
   for (const tok of tokens) {
     if (name.includes(tok) || id.includes(tok)) score += 2;
     if (tags.some((t) => t.includes(tok)) || aliases.some((a) => a.includes(tok))) score += 1;
@@ -109,15 +114,6 @@ export function scoreStandard(std, query) {
   return score;
 }
 
-/**
- * Rank standards against a query, applying optional category/tags filters
- * first. Returns the TOP 3 with score > 0, sorted desc (ties broken by id).
- *
- * @param {object[]} standards
- * @param {string} query
- * @param {{ category?: string, tags?: string[] }} [filters]
- * @returns {Array<object & { score: number }>}
- */
 export function findStandards(standards, query, filters = {}) {
   const category = filters.category?.toLowerCase();
   const tags = (filters.tags || []).map((t) => t.toLowerCase());
@@ -138,15 +134,11 @@ export function findStandards(standards, query, filters = {}) {
     .slice(0, 3);
 }
 
-/** Parse `--tags a,b,c` into a trimmed, non-empty array. */
 function parseTagsOption(raw) {
   if (!raw) return [];
   return String(raw).split(',').map((t) => t.trim()).filter(Boolean);
 }
 
-/**
- * @param {{ find?: string, category?: string, tags?: string, json?: boolean, cwd?: string }} [options]
- */
 export function standardsCommand(options = {}) {
   const cwd = options.cwd || process.cwd();
   const standardsJsonPath = resolveStandardsJsonPath(cwd);
@@ -159,16 +151,16 @@ export function standardsCommand(options = {}) {
 
   let registry;
   try {
-    registry = loadRegistry(standardsJsonPath);
+    registry = loadStandardsRegistry(standardsJsonPath);
   } catch (err) {
     console.error(chalk.red(`\n❌ STANDARDS.json inválido em ${standardsJsonPath}: ${err.message}\n`));
     process.exit(1);
   }
 
-  const standards = Array.isArray(registry.standards) ? registry.standards : [];
+  const standards = registry.standards;
+  if (options.show) showStandard(standards, standardsJsonPath, options.show, options.json);
   const query = (options.find || '').trim();
 
-  // ── Bare call (no --find): categories + counts, cheap orientation ────────
   if (!query) {
     const counts = categoryCounts(standards);
     if (options.json) {
@@ -180,11 +172,10 @@ export function standardsCommand(options = {}) {
     for (const { category, count } of counts) {
       console.log(`  ${col(category, 20)}${count}`);
     }
-    console.log(chalk.gray('\nUse --find "<query>" para buscar (top 3, com digest completo).\n'));
+    console.log(chalk.gray('\nUse --find "<query>" para buscar (top 3, com digest e âncoras) e --show <id>#<âncora> para ler uma seção.\n'));
     process.exit(0);
   }
 
-  // ── --find: score + filter ────────────────────────────────────────────
   const filters = { category: options.category, tags: parseTagsOption(options.tags) };
   const results = findStandards(standards, query, filters);
 
@@ -201,7 +192,8 @@ export function standardsCommand(options = {}) {
   }
 
   const shaped = results.map((r) => ({
-    id: r.id, name: r.name, path: r.path, category: r.category, digest: r.digest, score: r.score,
+    id: r.id, name: r.name, path: r.path, category: r.category, digest: r.digest,
+    anchors: Object.keys(r.anchors || {}), score: r.score,
   }));
 
   if (options.json) {
@@ -214,6 +206,7 @@ export function standardsCommand(options = {}) {
     console.log(chalk.cyan(`${i + 1}. ${r.id}`) + chalk.gray(`  (${r.category})`));
     console.log(`   ${r.path}`);
     console.log(chalk.gray(`   ${r.digest}`));
+    if (r.anchors.length) console.log(`   âncoras: ${r.anchors.join(', ')}` + chalk.gray(`  → morph-spec standards --show ${r.id}#<âncora>`));
     console.log('');
   });
   process.exit(0);

package/src/commands/project/status.js

@@ -1,23 +1,7 @@
-/**
- * MORPH-SPEC Feature Status Command
- *
- * Displays a comprehensive dashboard showing feature progress, phase status,
- * outputs, tasks, approvals, and next steps.
- *
- * Usage:
- *   morph-spec status <feature-name>
- *   morph-spec status <feature-name> --json
- *
- * Example:
- *   morph-spec status user-portal
- */
-
 import chalk from 'chalk';
 import { loadState, getFeature, derivePhase, deriveOutputs } from '../../core/state/state-manager.js';
+import { sliceProgress } from '../../../framework/hooks/shared/slice-progress.js';
 
-/**
- * Phase symbols for visual representation
- */
 const PHASE_SYMBOLS = {
   completed: '✅',
   current: '⏸️',
@@ -25,29 +9,27 @@ const PHASE_SYMBOLS = {
   skipped: '⊘'
 };
 
-/**
- * Phase definitions with order
- */
 const PHASE_ORDER = [
-  { key: 'proposal', name: 'FASE 0: PROPOSAL', order: 0 },
-  { key: 'uiux', name: 'FASE 1: UI/UX', order: 1, optional: true },
-  { key: 'plan', name: 'FASE 2: PLAN', order: 2 },
-  { key: 'implement', name: 'FASE 3: IMPLEMENT', order: 3 },
-  { key: 'review', name: 'FASE 4: REVIEW', order: 4 }
+  { key: 'plan', name: 'FASE 1: PLAN', order: 0 },
+  { key: 'uiux', name: 'FASE 2: UI/UX', order: 1, optional: true },
+  { key: 'implement', name: 'FASE 3: IMPLEMENT', order: 2 },
+  { key: 'review', name: 'FASE 4: REVIEW', order: 3 }
 ];
 
-/**
- * Calculate phase status (completed, current, pending, skipped)
- */
+const PHASE_OUTPUTS = {
+  plan: ['plan', 'checks'],
+  uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
+  implement: [],
+  review: ['verifierReport', 'reviewerReport']
+};
+
 function getPhaseStatus(phaseKey, currentPhase, feature) {
   const phase = PHASE_ORDER.find(p => p.key === phaseKey);
   const current = PHASE_ORDER.find(p => p.key === currentPhase);
 
   if (!phase || !current) return 'pending';
 
-  // Check if phase was skipped (optional phases)
   if (phase.optional && phase.order < current.order) {
-    // Check if any outputs were created for this phase
     const hasOutputs = checkPhaseOutputs(phaseKey, feature);
     if (!hasOutputs) return 'skipped';
   }
@@ -57,25 +39,11 @@ function getPhaseStatus(phaseKey, currentPhase, feature) {
   return 'pending';
 }
 
-/**
- * Check if phase has any outputs created
- */
 function checkPhaseOutputs(phaseKey, feature) {
-  const phaseOutputMap = {
-    proposal: ['proposal', 'stackScan'],
-    uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-    plan: ['spec', 'tasks', 'decisions'],
-    implement: ['recap'],
-    review: ['reviewReport']
-  };
-
-  const outputs = phaseOutputMap[phaseKey] || [];
+  const outputs = PHASE_OUTPUTS[phaseKey] || [];
   return outputs.some(output => feature.outputs[output]?.created);
 }
 
-/**
- * Format phase display with symbol and status
- */
 function formatPhase(phaseKey, currentPhase, feature, options = {}) {
   const phase = PHASE_ORDER.find(p => p.key === phaseKey);
   const status = getPhaseStatus(phaseKey, currentPhase, feature);
@@ -97,17 +65,8 @@ function formatPhase(phaseKey, currentPhase, feature, options = {}) {
     display = chalk.gray(display);
   }
 
-  // Add output files if verbose
   if (options.verbose && status !== 'pending' && status !== 'skipped') {
-    const phaseOutputMap = {
-      proposal: ['proposal', 'stackScan'],
-      uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-      plan: ['spec', 'tasks', 'decisions'],
-      implement: ['recap'],
-      review: ['reviewReport']
-    };
-
-    const outputs = phaseOutputMap[phaseKey] || [];
+    const outputs = PHASE_OUTPUTS[phaseKey] || [];
     const created = outputs.filter(o => feature.outputs[o]?.created);
     if (created.length > 0) {
       display += chalk.gray(`\n     Files: ${created.length}/${outputs.length}`);
@@ -117,11 +76,8 @@ function formatPhase(phaseKey, currentPhase, feature, options = {}) {
   return display;
 }
 
-/**
- * Calculate completion percentage
- */
 function calculateCompletionPercentage(feature) {
-  const totalPhases = PHASE_ORDER.filter(p => !p.optional).length; // 6 required phases
+  const totalPhases = PHASE_ORDER.filter(p => !p.optional).length;
   const completedPhases = PHASE_ORDER.filter(p => {
     if (p.optional) return false;
     const status = getPhaseStatus(p.key, feature.phase, feature);
@@ -131,17 +87,12 @@ function calculateCompletionPercentage(feature) {
   return Math.round((completedPhases / totalPhases) * 100);
 }
 
-/**
- * Get next steps based on current phase
- */
 function getNextSteps(feature) {
   const steps = [];
 
-  // Check for pending approvals relevant to current phase
   const phaseApprovalMap = {
-    proposal: 'proposal',
-    uiux: 'uiux',
     plan: 'plan',
+    uiux: 'uiux',
     implement: 'plan',
     review: 'review'
   };
@@ -157,15 +108,7 @@ function getNextSteps(feature) {
     });
   }
 
-  // Check for missing outputs in current phase
-  const phaseOutputMap = {
-    proposal: ['proposal'],
-    plan: ['spec', 'tasks'],
-    implement: ['recap'],
-    review: ['reviewReport']
-  };
-
-  const requiredOutputs = phaseOutputMap[feature.phase] || [];
+  const requiredOutputs = feature.phase === 'uiux' ? [] : PHASE_OUTPUTS[feature.phase] || [];
   const missingOutputs = requiredOutputs.filter(o => !feature.outputs[o]?.created);
 
   if (missingOutputs.length > 0) {
@@ -176,7 +119,6 @@ function getNextSteps(feature) {
     });
   }
 
-  // Suggest next phase if current is complete
   const hasApprovalPending = relevantGate && approvalGates[relevantGate] && !approvalGates[relevantGate].approved;
   if (missingOutputs.length === 0 && !hasApprovalPending) {
     const currentPhaseIndex = PHASE_ORDER.findIndex(p => p.key === feature.phase);
@@ -199,28 +141,6 @@ function getNextSteps(feature) {
   return steps;
 }
 
-/**
- * Estimate remaining time based on tasks
- */
-function estimateRemainingTime(feature) {
-  if (!feature.tasks || feature.tasks.total === 0) {
-    return 'Not estimated';
-  }
-
-  const remaining = feature.tasks.total - feature.tasks.completed;
-  const avgHoursPerTask = 2; // Configurable estimate
-  const hours = remaining * avgHoursPerTask;
-
-  if (hours < 1) return '< 1 hour';
-  if (hours === 1) return '1 hour';
-  if (hours < 8) return `${hours} hours`;
-  const days = Math.ceil(hours / 8);
-  return `~${days} day${days > 1 ? 's' : ''} (${hours}h)`;
-}
-
-/**
- * Main status command
- */
 export async function statusCommand(featureName, options = {}) {
   if (!featureName) {
     console.error(chalk.red('✗ Error: Feature name required'));
@@ -242,7 +162,6 @@ export async function statusCommand(featureName, options = {}) {
     process.exit(1);
   }
 
-  // Derive phase and outputs from filesystem if not stored in state
   const { join } = await import('path');
   const featurePath = join(process.cwd(), '.morph', 'features', featureName);
   if (!feature.phase) {
@@ -251,8 +170,8 @@ export async function statusCommand(featureName, options = {}) {
   if (!feature.outputs) {
     feature.outputs = deriveOutputs(featureName, process.cwd());
   }
+  const slices = sliceProgress(featurePath);
 
-  // JSON output mode
   if (options.json) {
     const status = {
       feature: featureName,
@@ -270,28 +189,24 @@ export async function statusCommand(featureName, options = {}) {
         created: output.created,
         path: output.path
       })),
-      tasks: feature.tasks || { total: 0, completed: 0, inProgress: 0, pending: 0 },
+      slices,
       approvals: feature.approvalGates || {},
-      nextSteps: getNextSteps(feature),
-      estimatedTimeRemaining: estimateRemainingTime(feature)
+      nextSteps: getNextSteps(feature)
     };
 
     console.log(JSON.stringify(status, null, 2));
     return;
   }
 
-  // Visual dashboard output
   console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
   console.log(chalk.cyan('│                   MORPH-SPEC STATUS                       │'));
   console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
 
-  // Feature info
   console.log(chalk.white.bold(`Feature: ${featureName}`));
   console.log(chalk.gray(`Status: ${feature.status || 'unknown'}`));
   console.log(chalk.gray(`Completion: ${calculateCompletionPercentage(feature)}%`));
   console.log('');
 
-  // Phase progression
   console.log(chalk.white.bold('Phases:'));
   console.log(chalk.cyan('├─────────────────────────────────────────────────────────────┤'));
   PHASE_ORDER.forEach(phase => {
@@ -300,7 +215,6 @@ export async function statusCommand(featureName, options = {}) {
   console.log(chalk.cyan('└─────────────────────────────────────────────────────────────┘'));
   console.log('');
 
-  // Outputs summary
   const totalOutputs = Object.keys(feature.outputs).length;
   const createdOutputs = Object.values(feature.outputs).filter(o => o.created).length;
   console.log(chalk.white.bold(`Outputs: ${createdOutputs}/${totalOutputs} complete`));
@@ -315,21 +229,16 @@ export async function statusCommand(featureName, options = {}) {
   }
   console.log('');
 
-  // Tasks progress
-  if (feature.tasks && feature.tasks.total > 0) {
-    console.log(chalk.white.bold('Tasks Progress:'));
-    const { total, completed, inProgress, pending } = feature.tasks;
-    const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
-
-    console.log(`  Total: ${total}`);
-    console.log(chalk.green(`  ✓ Completed: ${completed} (${percentage}%)`));
-    if (inProgress > 0) console.log(chalk.cyan(`  ▶ In Progress: ${inProgress}`));
-    if (pending > 0) console.log(chalk.gray(`  ⬜ Pending: ${pending}`));
-    console.log(`  Estimated time remaining: ${estimateRemainingTime(feature)}`);
+  if (slices && slices.total > 0) {
+    console.log(chalk.white.bold('Fatias:'));
+    const percentage = Math.round((slices.done / slices.total) * 100);
+    console.log(`  Total: ${slices.total}`);
+    console.log(chalk.green(`  ✓ Feitas: ${slices.done} (${percentage}%)`));
+    if (slices.partial > 0) console.log(chalk.cyan(`  ▶ Parciais: ${slices.partial}`));
+    if (slices.pending > 0) console.log(chalk.gray(`  ⬜ Pendentes: ${slices.pending}`));
     console.log('');
   }
 
-  // Approval gates
   if (feature.approvalGates) {
     const gates = Object.entries(feature.approvalGates);
     const approved = gates.filter(([_, g]) => g.approved).length;
@@ -349,7 +258,6 @@ export async function statusCommand(featureName, options = {}) {
     console.log('');
   }
 
-  // Next steps
   const nextSteps = getNextSteps(feature);
   if (nextSteps.length > 0) {
     console.log(chalk.white.bold('Next Steps:'));
@@ -361,10 +269,9 @@ export async function statusCommand(featureName, options = {}) {
     });
     console.log('');
   } else {
-    console.log(chalk.green('✓ All tasks complete!\n'));
+    console.log(chalk.green('✓ Nada pendente.\n'));
   }
 
-  // Footer
   console.log(chalk.gray('─'.repeat(60)));
   console.log(chalk.gray('Run with --verbose for detailed output'));
   console.log(chalk.gray('Run with --json for JSON output\n'));