@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.4

package/src/runtime/{claims.ts → claims.js}

@@ -6,11 +6,11 @@ const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
 // Shared with EvidenceLedger so both stores enforce one definition of a safe task id.
-const { assertSafeTaskId, EvidenceLedger } = require('./evidence-ledger.ts');
-const { updateTaskState, readTaskState, mergeRecords } = require('./task-state.ts');
-const { taskStoreDir } = require('./task-scope.ts');
-const { finishRuntime, usageError } = require('./cli-result.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { assertSafeTaskId, EvidenceLedger } = require('./evidence-ledger.js');
+const { updateTaskState, readTaskState, mergeRecords } = require('./task-state.js');
+const { taskStoreDir } = require('./task-scope.js');
+const { finishRuntime, usageError } = require('./cli-result.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 const CLAIM_STATUSES = new Set([
   'hypothesis',
@@ -38,15 +38,15 @@ const CLAIM_STATUSES = new Set([
 const TERMINAL_CLAIM_STATUSES = new Set(['retracted', 'superseded']);
 
 class ClaimsManager {
-  declare fsImpl: any;
-  declare evidenceLedger: any;
-  declare repoRoot: any;
-  declare fixedStateDir: any;
-  declare slug: any;
-  declare stateDir: any;
-  declare claimsMap: Map<any, any>;
-  declare baseline: Map<any, any>;
-  declare seq: number;
+                      
+                              
+                        
+                             
+                    
+                        
+                                   
+                                  
+                      
   /**
    * @param {Object} [options]
    * @param {Object} [options.evidenceLedger]
@@ -55,7 +55,7 @@ class ClaimsManager {
    * @param {string} [options.slug] feature whose namespace the records live under (see task-scope.js)
    * @param {Object} [options.fsImpl]
    */
-  constructor(options: any = {}) {
+  constructor(options      = {}) {
     this.fsImpl = options.fsImpl || fs;
     this.evidenceLedger = options.evidenceLedger || null;
     this.repoRoot = options.repoRoot || REPO_ROOT;
@@ -68,7 +68,7 @@ class ClaimsManager {
   }
 
   /** Where this task's claims file lives: beside its evidence, in the feature's namespace when it has one. */
-  fileFor(taskId: any) {
+  fileFor(taskId     ) {
     const dir = this.fixedStateDir
       || taskStoreDir({ projectRoot: this.repoRoot, store: 'evidence', taskId, slug: this.slug });
     return path.join(dir, `${assertSafeTaskId(taskId)}_claims.json`);
@@ -87,7 +87,7 @@ class ClaimsManager {
    * @param {Object} item - { statement, taskId, status, id, role }
    * @returns {string} claimId
    */
-  addClaim(item: any): string {
+  addClaim(item     )         {
     if (!item || typeof item !== 'object') {
       throw new Error('Claim item must be an object');
     }
@@ -125,7 +125,7 @@ class ClaimsManager {
    * @param {string} id
    * @returns {Object|null}
    */
-  getClaim(id: string) {
+  getClaim(id        ) {
     return this.claimsMap.get(id) || null;
   }
 
@@ -135,7 +135,7 @@ class ClaimsManager {
    * @param {string} evidenceId
    * @param {'supports'|'contradicts'} [relation='supports']
    */
-  linkEvidence(claimId: string, evidenceId: string, relation = 'supports') {
+  linkEvidence(claimId        , evidenceId        , relation = 'supports') {
     const claim = this.claimsMap.get(claimId);
     if (!claim) {
       throw new Error(`Unknown claim '${claimId}'`);
@@ -174,7 +174,7 @@ class ClaimsManager {
    * @param {string} claimId
    * @returns {'hypothesis'|'supported'|'conflicted'|'invalidated'|'unknown'}
    */
-  evaluateClaim(claimId: string) {
+  evaluateClaim(claimId        ) {
     const claim = this.claimsMap.get(claimId);
     if (!claim) {
       throw new Error(`Unknown claim '${claimId}'`);
@@ -239,7 +239,7 @@ class ClaimsManager {
    * @param {string} [supersededBy]
    * @returns {string} the new status
    */
-  finalizeClaim(claimId: string, status: any, supersededBy?: string): string {
+  finalizeClaim(claimId        , status     , supersededBy         )         {
     const claim = this.claimsMap.get(claimId);
     if (!claim) {
       throw new Error(`Unknown claim '${claimId}'`);
@@ -260,7 +260,7 @@ class ClaimsManager {
    * @param {string} claimId
    * @returns {string} the new status
    */
-  retractClaim(claimId: string): string {
+  retractClaim(claimId        )         {
     return this.finalizeClaim(claimId, 'retracted');
   }
 
@@ -273,7 +273,7 @@ class ClaimsManager {
    * @param {string} replacedBy
    * @returns {string} the new status
    */
-  supersedeClaim(claimId: string, replacedBy: string): string {
+  supersedeClaim(claimId        , replacedBy        )         {
     // The target is checked first: validating the replacement before the claim being superseded
     // reported a missing replacement when the caller had actually mistyped the target, sending them
     // to fix the wrong id.
@@ -307,7 +307,7 @@ class ClaimsManager {
    * @param {string} [taskId]
    * @returns {Array<Object>}
    */
-  getClaims(taskId: string) {
+  getClaims(taskId        ) {
     const results = [];
     for (const claim of this.claimsMap.values()) {
       if (!taskId || claim.taskId === taskId) {
@@ -322,13 +322,13 @@ class ClaimsManager {
    * @param {string} [taskId='default']
    * @returns {string} filePath
    */
-  save(taskId = 'default'): string {
+  save(taskId = 'default')         {
     const targetFile = this.fileFor(taskId);
-    let merged: any;
+    let merged     ;
     const file = updateTaskState({
       fsImpl: this.fsImpl,
       file: targetFile,
-      build: (disk: any) => {
+      build: (disk     ) => {
         merged = mergeRecords(this.getClaims(taskId), disk?.claims || [], this.baseline);
         return { taskId, updatedAt: new Date().toISOString(), claimsCount: merged.length, claims: merged };
       },
@@ -345,7 +345,7 @@ class ClaimsManager {
    * @param {string} [taskId='default']
    * @returns {number}
    */
-  load(taskId = 'default'): number {
+  load(taskId = 'default')         {
     const targetFile = this.fileFor(taskId);
     const data = readTaskState(this.fsImpl, targetFile);
     if (data && Array.isArray(data.claims)) {
@@ -385,7 +385,7 @@ class ClaimsManager {
  * @param {string} [options.slug] feature the task belongs to, when not the branch's
  * @returns {number} exit code
  */
-function handleClaimCommand({ taskId, action = 'list', statement, claimId, evidenceId, replacedBy, relation = 'supports', role, json = false, stateRoot, slug }: any = {}): number {
+function handleClaimCommand({ taskId, action = 'list', statement, claimId, evidenceId, replacedBy, relation = 'supports', role, json = false, stateRoot, slug }      = {})         {
   const root = stateRoot || process.cwd();
   const ledger = new EvidenceLedger({ repoRoot: root, slug });
   ledger.load(taskId);
@@ -437,7 +437,7 @@ function handleClaimCommand({ taskId, action = 'list', statement, claimId, evide
     } else {
       return usageError('claim', `unknown --action '${action}'. Valid: list, add, link, retract, supersede`, json);
     }
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('claim', error.message, json, error);
   }
 

package/src/runtime/{cli-result.ts → cli-result.js}

@@ -16,7 +16,7 @@
  * @param {number} code
  * @returns {number} the code, for chaining
  */
-function finishRuntime(code: number): number {
+function finishRuntime(code        )         {
   process.exitCode = code;
   return code;
 }
@@ -29,8 +29,8 @@ function finishRuntime(code: number): number {
  * @param {string} command the verb or installer command name
  * @param {number} exit the exit status the caller is about to produce
  */
-function captureCaught(error: any, command: string, exit: number): void {
-  try { require('./failure/capture.ts').captureError(error, { command, exit }); } catch { /* capture is best-effort */ }
+function captureCaught(error     , command        , exit        )       {
+  try { require('./failure/capture.js').captureError(error, { command, exit }); } catch { /* capture is best-effort */ }
 }
 
 /**
@@ -45,7 +45,7 @@ function captureCaught(error: any, command: string, exit: number): void {
  * @param {Error} [error]
  * @returns {number} 2 (USAGE error exit code)
  */
-function usageError(verb: string, message: string, json?: boolean, error?: Error): number {
+function usageError(verb        , message        , json          , error        )         {
   if (error !== undefined) captureCaught(error, verb, 2);
   if (json) console.log(JSON.stringify({ ok: false, status: 'USAGE', exitCode: 2, error: 'usage', summary: message }, null, 2));
   else console.error(`doflow ${verb}: ${message}`);

package/src/runtime/{cli.ts → cli.js}

@@ -6,18 +6,18 @@ const crypto = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { CapabilityRouter } = require('./capability-router.ts');
-const { EvidenceLedger, VALID_EVIDENCE_KINDS, VALID_PROVENANCE } = require('./evidence-ledger.ts');
-const { resolveLocator, describeResolution } = require('./locator-resolve.ts');
-const { ClaimsManager } = require('./claims.ts');
-const { measureFreshness } = require('./freshness.ts');
-const { evaluateTaskReadiness } = require('./readiness.ts');
-const { writeReadinessRecord } = require('./readiness-record.ts');
-const { parseDeclaredScope } = require('./verification/scope-bound.ts');
-const { loadRegistry } = require('../registry/index.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { CapabilityRouter } = require('./capability-router.js');
+const { EvidenceLedger, VALID_EVIDENCE_KINDS, VALID_PROVENANCE } = require('./evidence-ledger.js');
+const { resolveLocator, describeResolution } = require('./locator-resolve.js');
+const { ClaimsManager } = require('./claims.js');
+const { measureFreshness } = require('./freshness.js');
+const { evaluateTaskReadiness } = require('./readiness.js');
+const { writeReadinessRecord } = require('./readiness-record.js');
+const { parseDeclaredScope } = require('./verification/scope-bound.js');
+const { loadRegistry } = require('../registry/index.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 // One definition of the exit and usage helpers (design §4.2); `finish` is the local spelling of `finishRuntime`.
-const { finishRuntime: finish, usageError } = require('./cli-result.ts');
+const { finishRuntime: finish, usageError } = require('./cli-result.js');
 
 /**
  * Handles `doflow capabilities` command execution.
@@ -26,7 +26,7 @@ const { finishRuntime: finish, usageError } = require('./cli-result.ts');
  * @param {boolean} [options.check=false]
  * @param {string} [options.repoRoot]
  */
-function handleCapabilitiesCommand({ json = false, check = false, repoRoot }: any = {}) {
+function handleCapabilitiesCommand({ json = false, check = false, repoRoot }      = {}) {
   const root = repoRoot || REPO_ROOT;
   const router = new CapabilityRouter({ repoRoot: root });
   const report = router.getAllCapabilitiesHealth(check);
@@ -92,7 +92,7 @@ function handleCapabilitiesCommand({ json = false, check = false, repoRoot }: an
 function handleReadinessCommand({
   taskClass = 'feature', taskId = 'default', json = false, repoRoot, stateRoot,
   verificationPlan, scopeClear, invariants, userDecisionPending = false, mode = 'workflow', now, slug = null,
-}: any = {}) {
+}      = {}) {
   // Two different roots, previously conflated into one. `root` locates the *registry* (the
   // readiness templates ship inside the DoFlow package). `state` locates the invoking project's
   // evidence, which belongs to the caller's repo — not to wherever DoFlow happens to be installed.
@@ -102,7 +102,7 @@ function handleReadinessCommand({
   const state = stateRoot || process.cwd();
   // Only what the caller actually told us. An absent key must stay absent rather than become a
   // falsy default, because the engine reads presence, not truth.
-  const profile: any = { taskId, taskClass };
+  const profile      = { taskId, taskClass };
   if (typeof verificationPlan === 'string' && verificationPlan.trim() !== '') profile.verificationPlan = verificationPlan;
   if (typeof scopeClear === 'string' && scopeClear.trim() !== '') profile.scopeClear = scopeClear;
   if (typeof invariants === 'string' && invariants.trim() !== '') profile.invariants = invariants;
@@ -112,25 +112,25 @@ function handleReadinessCommand({
   let report;
   try {
     report = evaluateTaskReadiness({ taskProfile: profile, repoRoot: root, projectRoot: state, mode });
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('readiness', error.message, json, error);
   }
 
   // The evaluation is recorded so the handoff, `verify` and the edit hook can later ask whether
   // this task was READY before its work began. A scope that parses as a path list is also the
   // declared scope `verify` bounds a change by; any other wording stays a statement only.
-  const inputs: any = {};
+  const inputs      = {};
   if (profile.verificationPlan) inputs.verificationPlan = profile.verificationPlan;
   if (profile.scopeClear) inputs.scope = profile.scopeClear;
   if (profile.invariants) inputs.invariants = profile.invariants;
   if (profile.userDecisionPending) inputs.userDecisionPending = true;
   const declared = inputs.scope ? parseDeclaredScope(inputs.scope) : null;
   const declaredScope = declared && !declared.reason ? declared.paths : null;
-  let recorded: any;
+  let recorded     ;
   try {
     const { file, replacedUnreadable } = writeReadinessRecord({ stateRoot: state, taskId, slug, report, inputs, declaredScope, mode, now: now || new Date() });
     recorded = { file, written: true, ...(replacedUnreadable ? { replacedUnreadable } : {}) };
-  } catch (error: any) {
+  } catch (error     ) {
     recorded = { file: null, written: false, error: error.message };
   }
   const exitCode = recorded.written ? 0 : 1;
@@ -232,7 +232,7 @@ const EVIDENCE_SCORE_FIELDS = new Set([
 ]);
 
 /** The one refusal message for a score offered as a property of a fact. */
-function scoreFieldRefusal(name: any) {
+function scoreFieldRefusal(name     ) {
   return `'${name}' is a retrieval score and this boundary records none (FR-007). Relevance is a `
     + 'property of a search, not of a fact: stored beside the fact it is read as confidence by the '
     + 'next worker, which is the specific interpretation the requirement forbids. Record the '
@@ -241,7 +241,7 @@ function scoreFieldRefusal(name: any) {
 }
 
 /** Refuses a score-shaped key anywhere in an item, including nested under source or locator. */
-function assertNoScoreFields(value: any, prefix: any) {
+function assertNoScoreFields(value     , prefix     ) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return;
   for (const [key, inner] of Object.entries(value)) {
     const dotted = prefix ? `${prefix}.${key}` : key;
@@ -255,7 +255,7 @@ function assertNoScoreFields(value: any, prefix: any) {
  * @param {Object|string} raw
  * @returns {Object}
  */
-function parseLocator(raw: any) {
+function parseLocator(raw     ) {
   if (typeof raw === 'string') {
     const text = raw.trim();
     if (text === '') throw new Error('locator is empty');
@@ -267,7 +267,7 @@ function parseLocator(raw: any) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
     throw new Error("locator must be an object, or a 'path/to/file[:line]' or URI string");
   }
-  const locator: Record<string, any> = {};
+  const locator                      = {};
   for (const [key, value] of Object.entries(raw)) {
     if (!EVIDENCE_LOCATOR_FIELDS.includes(key)) {
       throw new Error(`unknown locator field '${key}'. Accepted: ${EVIDENCE_LOCATOR_FIELDS.join(', ')}`);
@@ -298,7 +298,7 @@ function parseLocator(raw: any) {
  * @param {string} [repoRoot] root a relative locator resolves against; defaults to cwd
  * @returns {{kind:string, provenance:string, source:Object, locator:Object, content:(string|null)}}
  */
-function validateEvidenceItem(raw: any, taskId: any, repoRoot: any) {
+function validateEvidenceItem(raw     , taskId     , repoRoot     ) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('an evidence item must be a JSON object');
   assertNoScoreFields(raw, '');
 
@@ -381,7 +381,7 @@ function validateEvidenceItem(raw: any, taskId: any, repoRoot: any) {
   // `blast_radius` at once by category alone (review R1).
   let establishes = [];
   if (raw.establishes !== undefined) {
-    const list = typeof raw.establishes === 'string' ? raw.establishes.split(',').map((s: any) => s.trim()) : raw.establishes;
+    const list = typeof raw.establishes === 'string' ? raw.establishes.split(',').map((s     ) => s.trim()) : raw.establishes;
     if (!Array.isArray(list) || list.length === 0 || list.some((r) => typeof r !== 'string' || r.trim() === '')) {
       throw new Error("'establishes' must be a requirement id, a comma-separated list of them, or a non-empty array of non-empty strings");
     }
@@ -436,7 +436,7 @@ function validateEvidenceItem(raw: any, taskId: any, repoRoot: any) {
 }
 
 /** HEAD of the tree the evidence was observed in, or null outside a repo. Measured, not asserted. */
-function headCommit(root: any) {
+function headCommit(root     ) {
   try {
     return execFileSync('git', ['-C', root, 'rev-parse', 'HEAD'], {
       encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
@@ -452,17 +452,17 @@ function headCommit(root: any) {
  * @param {string} batchPath a file path, or `-` for stdin
  * @returns {Array<Object>}
  */
-function readEvidenceBatch(batchPath: any) {
+function readEvidenceBatch(batchPath     ) {
   let text;
   try {
     text = batchPath === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(batchPath), 'utf8');
-  } catch (error: any) {
+  } catch (error     ) {
     throw new Error(`cannot read the batch at '${batchPath}': ${error.message}`);
   }
   let data;
   try {
     data = JSON.parse(text);
-  } catch (error: any) {
+  } catch (error     ) {
     throw new Error(`the batch at '${batchPath}' is not valid JSON: ${error.message}`);
   }
   if (Array.isArray(data)) return data;
@@ -483,7 +483,7 @@ function readEvidenceBatch(batchPath: any) {
  * The `--action add` arm: validate the whole batch, then write it.
  * @returns {number} exit code
  */
-function addEvidence({ ledger, root, taskId, item, batchPath, json }: any) {
+function addEvidence({ ledger, root, taskId, item, batchPath, json }     ) {
   const flagged = item && Object.keys(item).length > 0;
   if (flagged && batchPath) {
     return usageError('evidence', '--batch and the single-item flags are two spellings of the same write; use one', json);
@@ -496,7 +496,7 @@ function addEvidence({ ledger, root, taskId, item, batchPath, json }: any) {
   let raws;
   try {
     raws = batchPath ? readEvidenceBatch(batchPath) : [item];
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('evidence', error.message, json, error);
   }
   if (raws.length === 0) {
@@ -510,7 +510,7 @@ function addEvidence({ ledger, root, taskId, item, batchPath, json }: any) {
   for (const [index, raw] of raws.entries()) {
     try {
       validated.push(validateEvidenceItem(raw, taskId, root));
-    } catch (error: any) {
+    } catch (error     ) {
       const where = raws.length > 1 ? `batch item ${index + 1} of ${raws.length}: ` : '';
       return usageError('evidence', `${where}${error.message}`, json, error);
     }
@@ -529,7 +529,7 @@ function addEvidence({ ledger, root, taskId, item, batchPath, json }: any) {
       written.push(ledger.getEvidence(id));
     }
     stateFile = ledger.save(taskId);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('evidence', error.message, json, error);
   }
 
@@ -558,7 +558,7 @@ function addEvidence({ ledger, root, taskId, item, batchPath, json }: any) {
 }
 
 /** One-line rendering of a locator for the table views. */
-function locatorText(locator: any) {
+function locatorText(locator     ) {
   if (!locator) return '';
   if (locator.file) return locator.line ? `${locator.file}:${locator.line}` : locator.file;
   return locator.uri || locator.symbol || '';
@@ -569,14 +569,14 @@ function locatorText(locator: any) {
  * `handleClaimCommand`'s `supersede` branch — validate, write, save, report the same shape.
  * @returns {number} exit code
  */
-function supersedeEvidence({ ledger, taskId, evidenceId, replacedBy, json }: any) {
+function supersedeEvidence({ ledger, taskId, evidenceId, replacedBy, json }     ) {
   if (!evidenceId || !replacedBy) {
     return usageError('evidence', '--evidence-id and --replaced-by are both required for --action supersede', json);
   }
   let status;
   try {
     status = ledger.supersedeEvidence(evidenceId, replacedBy);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('evidence', error.message, json, error);
   }
   const stateFile = ledger.save(taskId);
@@ -610,7 +610,7 @@ function supersedeEvidence({ ledger, taskId, evidenceId, replacedBy, json }: any
  * @param {string} [options.stateRoot]
  * @returns {number} exit code
  */
-function handleEvidenceCommand({ taskId = 'default', action = 'list', item = null, batchPath = null, evidenceId = null, replacedBy = null, json = false, repoRoot, stateRoot }: any = {}) {
+function handleEvidenceCommand({ taskId = 'default', action = 'list', item = null, batchPath = null, evidenceId = null, replacedBy = null, json = false, repoRoot, stateRoot }      = {}) {
   // See handleReadinessCommand: evidence is the caller's project state, not DoFlow package state.
   const root = stateRoot || repoRoot || process.cwd();
   const isQuery = action === 'list' || action === 'status';
@@ -626,7 +626,7 @@ function handleEvidenceCommand({ taskId = 'default', action = 'list', item = nul
   const ledger = new EvidenceLedger({ repoRoot: root });
   try {
     ledger.load(taskId);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('evidence', error.message, json, error);
   }