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

package/src/runtime/{retrieval-plan.ts → retrieval-plan.js}

@@ -40,16 +40,16 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { CapabilityRouter } = require('./capability-router.ts');
-const { EvidenceLedger, assertSafeTaskId } = require('./evidence-ledger.ts');
-const { taskStoreDir } = require('./task-scope.ts');
-const { probeFreshness } = require('./health.ts');
+const { CapabilityRouter } = require('./capability-router.js');
+const { EvidenceLedger, assertSafeTaskId } = require('./evidence-ledger.js');
+const { taskStoreDir } = require('./task-scope.js');
+const { probeFreshness } = require('./health.js');
 // One definition of the score refusal, applied at a second boundary. See the note on
 // EVIDENCE_SCORE_FIELDS in cli.js: relevance is a property of a search, not of a fact, and a plan
 // that recorded one would hand the next worker a confidence dressed as a measurement.
-const { assertNoScoreFields } = require('./cli.ts');
-const { finishRuntime, usageError } = require('./cli-result.ts');
-const { REPO_ROOT } = require('../helper/repo-root.ts');
+const { assertNoScoreFields } = require('./cli.js');
+const { finishRuntime, usageError } = require('./cli-result.js');
+const { REPO_ROOT } = require('../helper/repo-root.js');
 
 // ── the closed result vocabulary (design §4) ─────────────────────────────────────────────────
 
@@ -84,7 +84,7 @@ const FRESHNESS_STATES = Object.freeze(['FRESH', 'STALE', 'UNKNOWN', NOT_APPLICA
  * this module exists to prevent — so staleness travels as a marker beside `EMPTY`, and the
  * provider's `refresh` command travels with it so the remedy is one step away.
  */
-const EMPTY_ANSWER_BY_FRESHNESS: Record<string, any> = Object.freeze({
+const EMPTY_ANSWER_BY_FRESHNESS                      = Object.freeze({
   UNKNOWN: UNVERIFIED,
   STALE: EMPTY,
   FRESH: EMPTY,
@@ -96,7 +96,7 @@ const EMPTY_ANSWER_BY_FRESHNESS: Record<string, any> = Object.freeze({
  * @param {string} freshnessState one of FRESHNESS_STATES
  * @returns {string} one of RESULTS
  */
-function resultForEmptyAnswer(freshnessState: any) {
+function resultForEmptyAnswer(freshnessState     ) {
   const mapped = EMPTY_ANSWER_BY_FRESHNESS[freshnessState];
   if (!mapped) {
     // Fail closed rather than pick a default: an unrecognised freshness token means the record was
@@ -119,7 +119,7 @@ function resultForEmptyAnswer(freshnessState: any) {
  * @param {string|null} [slug] the feature the task belongs to, when not the branch's (task-scope.js)
  * @returns {string}
  */
-function planPath(projectRoot: any, taskId: any, slug: any = null) {
+function planPath(projectRoot     , taskId     , slug      = null) {
   const dir = taskStoreDir({ projectRoot, store: 'retrieval', taskId: assertSafeTaskId(taskId), slug });
   return path.join(dir, `${taskId}.json`);
 }
@@ -129,12 +129,12 @@ function planPath(projectRoot: any, taskId: any, slug: any = null) {
  * @param {string} taskId
  * @returns {Object|null} the record, or null when no plan was declared
  */
-function readPlan(projectRoot: any, taskId: any, slug: any = null) {
+function readPlan(projectRoot     , taskId     , slug      = null) {
   const file = planPath(projectRoot, taskId, slug);
   if (!fs.existsSync(file)) return null;
   try {
     return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch (error: any) {
+  } catch (error     ) {
     throw new Error(`the retrieval plan at '${file}' is not readable: ${error.message}`);
   }
 }
@@ -145,7 +145,7 @@ function readPlan(projectRoot: any, taskId: any, slug: any = null) {
  * @param {Object} record
  * @returns {string} the file written
  */
-function writePlan(projectRoot: any, taskId: any, record: any, slug: any = null) {
+function writePlan(projectRoot     , taskId     , record     , slug      = null) {
   const file = planPath(projectRoot, taskId, slug);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
@@ -161,16 +161,16 @@ function writePlan(projectRoot: any, taskId: any, record: any, slug: any = null)
  * @param {Object} capabilities the router's `capabilities` map
  * @returns {(providerId: string) => string|null} the declared mode, or null for an unknown id
  */
-function sourceModeLookup(capabilities: any) {
+function sourceModeLookup(capabilities     ) {
   const modes = new Map();
-  for (const capability of Object.values<any>(capabilities || {})) {
+  for (const capability of Object.values     (capabilities || {})) {
     for (const provider of (capability && capability.providers) || []) {
       if (!provider || !provider.id) continue;
       if (modes.get(provider.id) === 'index') continue;
       modes.set(provider.id, provider.sourceMode || null);
     }
   }
-  return (providerId: any) => (modes.has(providerId) ? modes.get(providerId) : null);
+  return (providerId     ) => (modes.has(providerId) ? modes.get(providerId) : null);
 }
 
 /**
@@ -186,7 +186,7 @@ function sourceModeLookup(capabilities: any) {
  *   absent, every provider without an artifact layout is treated as unknown (fail closed)
  * @returns {{state: string, artifact: string|null, refresh: string|null, label: string|null, reason: string|null}}
  */
-function freshnessEntry(providerId: any, projectRoot: any, sourceModeOf: any = () => null) {
+function freshnessEntry(providerId     , projectRoot     , sourceModeOf      = () => null) {
   const probe = probeFreshness(providerId, { root: projectRoot });
   if (!probe) {
     // `probeFreshness` returns null for a provider it has no artifact layout for. What that means
@@ -230,9 +230,9 @@ function freshnessEntry(providerId: any, projectRoot: any, sourceModeOf: any = (
  * @param {Object} need
  * @returns {string} one of FRESHNESS_STATES
  */
-function freshnessOf(record: any, need: any) {
+function freshnessOf(record     , need     ) {
   if (!need.provider) return NOT_APPLICABLE;
-  const entry: any = record.providers && record.providers[need.provider];
+  const entry      = record.providers && record.providers[need.provider];
   return entry && entry.state ? entry.state : NOT_APPLICABLE;
 }
 
@@ -248,14 +248,14 @@ function freshnessOf(record: any, need: any) {
  * @param {Array<Object>} items
  * @returns {Array<string>} evidence ids
  */
-function evidenceIdsFor(need: any, items: any) {
+function evidenceIdsFor(need     , items     ) {
   return items
-    .filter((item: any) => {
+    .filter((item     ) => {
       const source = item.source || {};
       if (need.provider && source.provider === need.provider) return true;
       return Boolean(need.capability) && source.capability === need.capability;
     })
-    .map((item: any) => item.id);
+    .map((item     ) => item.id);
 }
 
 // ── actions ───────────────────────────────────────────────────────────────────────────────────
@@ -274,13 +274,13 @@ function evidenceIdsFor(need: any, items: any) {
  *
  * @returns {number} exit code
  */
-function declarePlan({ router, projectRoot, taskId, stage, intents, json, slug }: any) {
+function declarePlan({ router, projectRoot, taskId, stage, intents, json, slug }     ) {
   const needs = [];
   for (const intent of intents) {
     let resolution;
     try {
       resolution = router.resolveIntent(intent);
-    } catch (error: any) {
+    } catch (error     ) {
       // A misspelled intent is a caller error, not an unresolvable need. Recording it as
       // declared-unresolvable would file a typo as a machine limitation and hide it until report.
       return usageError('retrieval-plan',
@@ -299,8 +299,8 @@ function declarePlan({ router, projectRoot, taskId, stage, intents, json, slug }
 
   // R8, in one loop: the probe set is the set of DISTINCT providers, so cost is bounded by
   // provider count and not by need count. Six needs across two providers pay two scans.
-  const providers: Record<string, any> = {};
-  const sourceModeOf: any = sourceModeLookup(router.capabilities);
+  const providers                      = {};
+  const sourceModeOf      = sourceModeLookup(router.capabilities);
   for (const need of needs) {
     if (!need.provider || providers[need.provider]) continue;
     providers[need.provider] = freshnessEntry(need.provider, projectRoot, sourceModeOf);
@@ -367,11 +367,11 @@ function declarePlan({ router, projectRoot, taskId, stage, intents, json, slug }
  *
  * @returns {number} exit code
  */
-function reportPlan({ projectRoot, taskId, reached, json, slug }: any) {
+function reportPlan({ projectRoot, taskId, reached, json, slug }     ) {
   let record;
   try {
     record = readPlan(projectRoot, taskId, slug);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('retrieval-plan', error.message, json, error);
   }
   if (!record) {
@@ -381,7 +381,7 @@ function reportPlan({ projectRoot, taskId, reached, json, slug }: any) {
       + 'plan would state that nothing was missed, which is not something an absent plan can establish', json);
   }
 
-  const declared = new Set(record.needs.map((need: any) => need.intent));
+  const declared = new Set(record.needs.map((need     ) => need.intent));
   const undeclared = [...reached].filter((intent) => !declared.has(intent)).sort();
   if (undeclared.length > 0) {
     return usageError('retrieval-plan',
@@ -392,7 +392,7 @@ function reportPlan({ projectRoot, taskId, reached, json, slug }: any) {
   const ledger = new EvidenceLedger({ repoRoot: projectRoot, slug });
   try {
     ledger.load(taskId);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('retrieval-plan', error.message, json, error);
   }
   const items = ledger.queryEvidence({ taskId });
@@ -409,8 +409,8 @@ function reportPlan({ projectRoot, taskId, reached, json, slug }: any) {
 
   // Derived views, computed at emit and never stored on a need — a need holds a provider id and
   // nothing about that provider's index (plan D7).
-  const byResult = (result: any) => record.needs.filter((need: any) => need.result === result).map((need: any) => need.intent);
-  const stale = record.needs.filter((need: any) => freshnessOf(record, need) === 'STALE').map((need: any) => need.intent);
+  const byResult = (result     ) => record.needs.filter((need     ) => need.result === result).map((need     ) => need.intent);
+  const stale = record.needs.filter((need     ) => freshnessOf(record, need) === 'STALE').map((need     ) => need.intent);
   const unreached = byResult(UNREACHED);
   const unverified = byResult(UNVERIFIED);
   const incomplete = unreached.length > 0 || unverified.length > 0;
@@ -465,8 +465,8 @@ function reportPlan({ projectRoot, taskId, reached, json, slug }: any) {
 }
 
 /** The provider index block both actions print: state, what was located, and the remedy. */
-function printProviderIndexes(record: any) {
-  const entries = Object.entries<any>(record.providers || {});
+function printProviderIndexes(record     ) {
+  const entries = Object.entries     (record.providers || {});
   if (entries.length === 0) return;
   console.log('─'.repeat(78));
   console.log('Provider indexes (probed once each, at declare time):');
@@ -481,9 +481,9 @@ function printProviderIndexes(record: any) {
 // ── the verb ──────────────────────────────────────────────────────────────────────────────────
 
 /** `--need a,b --need c` and `--need a --need b` are the same list. */
-function parseIntents(raw: any) {
+function parseIntents(raw     ) {
   const list = Array.isArray(raw) ? raw : (raw === undefined || raw === null ? [] : [raw]);
-  const out: any = [];
+  const out      = [];
   for (const entry of list) {
     for (const token of String(entry).split(',')) {
       const trimmed = token.trim();
@@ -507,7 +507,7 @@ function parseIntents(raw: any) {
  * @param {string} [options.stateRoot] the project the task belongs to; its state and its index
  * @returns {number} exit code
  */
-function handleRetrievalPlanCommand(options: any = {}) {
+function handleRetrievalPlanCommand(options      = {}) {
   const { taskId, action = 'report', need, stage, json = false, repoRoot, stateRoot, slug } = options;
 
   // NFR-001, at the boundary where a caller's input first becomes a record. `bin/doflow.js` already
@@ -515,7 +515,7 @@ function handleRetrievalPlanCommand(options: any = {}) {
   // option object, so a second input surface cannot arrive later without inheriting the refusal.
   try {
     assertNoScoreFields(options, '');
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('retrieval-plan', error.message, json, error);
   }
 
@@ -534,7 +534,7 @@ function handleRetrievalPlanCommand(options: any = {}) {
 
   try {
     assertSafeTaskId(taskId);
-  } catch (error: any) {
+  } catch (error     ) {
     return usageError('retrieval-plan', error.message, json, error);
   }
 
@@ -552,7 +552,7 @@ function handleRetrievalPlanCommand(options: any = {}) {
     let router;
     try {
       router = new CapabilityRouter({ repoRoot: packageRoot });
-    } catch (error: any) {
+    } catch (error     ) {
       return usageError('retrieval-plan', error.message, json, error);
     }
     return declarePlan({ router, projectRoot, taskId, stage, intents, json, slug });

package/src/runtime/scaffold/{artifacts.ts → artifacts.js}

@@ -13,7 +13,7 @@
  */
 
 /** Returns the body of the first `## …<title>…` section, or null when there is none. */
-function section(text: string, titlePattern: RegExp): string | null {
+function section(text        , titlePattern        )                {
   const lines = text.split('\n');
   let start = -1;
   for (let i = 0; i < lines.length; i += 1) {
@@ -28,7 +28,7 @@ function section(text: string, titlePattern: RegExp): string | null {
 }
 
 /** Splits a markdown table row into trimmed cells, or null when the line is not a row. */
-function row(line: string): string[] | null {
+function row(line        )                  {
   if (!/^\s*\|/.test(line)) return null;
   const cells = line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
   if (cells.every((c) => /^:?-{3,}:?$/.test(c))) return null;   // the header separator
@@ -36,8 +36,8 @@ function row(line: string): string[] | null {
 }
 
 /** Markdown wraps long list items; a criterion or task split over three lines is still one item. */
-function joinWrapped(body: string): string[] {
-  const out: string[] = [];
+function joinWrapped(body        )           {
+  const out           = [];
   for (const line of body.split('\n')) {
     if (/^\s+\S/.test(line) && out.length && out[out.length - 1].trim() !== '') {
       out[out.length - 1] += ` ${line.trim()}`;
@@ -52,9 +52,9 @@ function joinWrapped(body: string): string[] {
  * `requirement.md` → requirement summaries (for traceability headers) and acceptance criteria
  * (for test stubs).
  */
-function parseRequirement(text: string): any {
-  const gaps: any[] = [];
-  const requirements = new Map<string, any>();
+function parseRequirement(text        )      {
+  const gaps        = [];
+  const requirements = new Map             ();
 
   const frBody = section(text, /Functional Requirements/i) ?? '';
   const nfrBody = section(text, /Non-Functional Requirements/i) ?? '';
@@ -72,7 +72,7 @@ function parseRequirement(text: string): any {
     gaps.push({ artifact: 'requirement.md', what: 'requirement index', why: 'no `| FR-nnn | … |` table row found under a Functional Requirements heading' });
   }
 
-  const criteria: any[] = [];
+  const criteria        = [];
   const acceptanceBody = section(text, /Acceptance Criteria/i);
   if (acceptanceBody === null) {
     gaps.push({ artifact: 'requirement.md', what: 'acceptance criteria', why: 'no "Acceptance Criteria" section — no test stubs can be derived' });
@@ -96,9 +96,9 @@ function parseRequirement(text: string): any {
  * `design.md` → the component index (traceability) and whatever §4 declares as an interface
  * (carried through verbatim rather than paraphrased).
  */
-function parseDesign(text: string): any {
-  const gaps: any[] = [];
-  const components = new Map<string, any>();
+function parseDesign(text        )      {
+  const gaps        = [];
+  const components = new Map             ();
 
   const body = section(text, /Components\s*(&|and)\s*Boundaries/i) ?? '';
   for (const line of body.split('\n')) {
@@ -121,9 +121,9 @@ function parseDesign(text: string): any {
     gaps.push({ artifact: 'design.md', what: 'interface contracts', why: 'no "API / Interface Contracts" section — every emitted file falls back to a placeholder signature' });
   } else {
     const lines = contractBody.split('\n');
-    let heading: string | null = null;
-    let fence: string | null = null;
-    let buffer: string[] = [];
+    let heading                = null;
+    let fence                = null;
+    let buffer           = [];
     for (const line of lines) {
       const headingMatch = line.match(/^###\s+(.*)$/);
       if (headingMatch && fence === null) { heading = headingMatch[1].trim(); continue; }
@@ -155,9 +155,9 @@ function parseDesign(text: string): any {
 const TASK_KEYS = ['owner', 'files', 'depends-on', 'external-contract'];
 
 /** `plan.md` → the task list, which is where the intended file layout actually comes from. */
-function parsePlan(text: string): any {
-  const gaps: any[] = [];
-  const tasks: any[] = [];
+function parsePlan(text        )      {
+  const gaps        = [];
+  const tasks        = [];
 
   // Anchored on the whole heading: `### Task Summary` is orientation, not the task list, and a
   // loose match would read the summary table's rows as tasks.
@@ -182,14 +182,14 @@ function parsePlan(text: string): any {
     const stories = [...new Set(head.match(/US\d+/g) || [])].sort();
     const description = head.replace(/\[P\]/g, '').replace(/\[US\d+\]/g, '').replace(/\s{2,}/g, ' ').trim();
 
-    const fields: Record<string, string> = {};
+    const fields                         = {};
     for (const chunk of meta.split(';')) {
       const fieldMatch = chunk.match(/^\s*([a-z-]+):\s*(.*)$/);
       if (!fieldMatch || !TASK_KEYS.includes(fieldMatch[1])) continue;
       fields[fieldMatch[1]] = fieldMatch[2].trim();
     }
 
-    const list = (value: string | undefined) => (value ? value.split(',').map((v) => v.replace(/`/g, '').trim()).filter(Boolean) : []);
+    const list = (value                    ) => (value ? value.split(',').map((v) => v.replace(/`/g, '').trim()).filter(Boolean) : []);
 
     tasks.push({
       id,

package/src/runtime/scaffold/{fingerprint.ts → fingerprint.js}

@@ -17,7 +17,7 @@ const crypto = require('node:crypto');
 const FINGERPRINT_MARKER = 'doflow-scaffold-fingerprint';
 const FINGERPRINT_RE = new RegExp(`${FINGERPRINT_MARKER} sha256:([0-9a-f]{64})`);
 
-function sha256(text: string): string {
+function sha256(text        )         {
   return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
 }
 
@@ -28,7 +28,7 @@ function sha256(text: string): string {
  * reading as human-edited; and it lives in the file rather than in a side ledger, so a scaffold
  * copied, moved or committed on its own still carries the evidence needed to protect it.
  */
-function compose(emitter: any, headerLines: string[], body: string): string {
+function compose(emitter     , headerLines          , body        )         {
   const fingerprint = sha256(body);
   const header = [
     ...headerLines.map((l) => emitter.line(l)),
@@ -38,7 +38,7 @@ function compose(emitter: any, headerLines: string[], body: string): string {
 }
 
 /** The hash a file claims for its own body, and the body it actually has. */
-function inspectExisting(text: string): { claimed: string | null; actual: string | null; body: string | null } {
+function inspectExisting(text        )                                                                         {
   const match = text.match(FINGERPRINT_RE);
   if (!match) return { claimed: null, actual: null, body: null };
   const cut = text.indexOf('\n', text.indexOf(match[0]));