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

package/src/runtime/{command-detect.ts → command-detect.js}

@@ -32,7 +32,7 @@ const path = require('node:path');
 
 /** The roles a tier in `verification.json` can ask for. Anything else in an override is an error,
  * because a typo'd key that is silently ignored is a command the user believes is running. */
-const COMMAND_ROLES: readonly string[] = Object.freeze([
+const COMMAND_ROLES                    = Object.freeze([
   'parse',
   'build',
   'lint',
@@ -60,14 +60,14 @@ const GLOB_CHARS = /[*?[{]/;
  * segment that has one (`test/**\/*.test.js` -> `test`, `**\/*.test.js` -> `.`); a plain file or
  * directory is kept as written. Duplicates are dropped.
  */
-function testRootsFromArgs(args: Array<string>): Array<string> {
-  const roots: Array<string> = [];
+function testRootsFromArgs(args               )                {
+  const roots                = [];
   for (const arg of args) {
     const bare = arg.replace(/^(["'])(.*)\1$/, '$2');
     let root = bare;
     if (GLOB_CHARS.test(bare)) {
       const segments = bare.split('/');
-      const firstGlob = segments.findIndex((segment: string) => GLOB_CHARS.test(segment));
+      const firstGlob = segments.findIndex((segment        ) => GLOB_CHARS.test(segment));
       root = segments.slice(0, firstGlob).join('/') || (bare.startsWith('/') ? '/' : '.');
     }
     if (!roots.includes(root)) roots.push(root);
@@ -85,19 +85,19 @@ const SHELL_SYNTAX = /[&|;<>$`()\\]/;
  * while leaving a targeted variant behind would report a tier as runnable that the plan just said
  * does not exist.
  */
-const DERIVED_ROLES: Readonly<Record<string, string>> = Object.freeze({ testTargeted: 'test' });
+const DERIVED_ROLES                                   = Object.freeze({ testTargeted: 'test' });
 
 /**
  * How a command was arrived at. `declared` means a human or a manifest script named it exactly;
  * `inferred` means this module constructed it from the toolchain's conventions and it may be wrong.
  * Kept out of any numeric form on purpose — FR-008 forbids numeric confidence in output paths.
  */
-const DERIVATIONS: readonly string[] = Object.freeze(['declared', 'inferred', 'override']);
+const DERIVATIONS                    = Object.freeze(['declared', 'inferred', 'override']);
 
-function readFileIfPresent(filePath: string, fsImpl: any): string | null {
+function readFileIfPresent(filePath        , fsImpl     )                {
   try {
     return fsImpl.readFileSync(filePath, 'utf8');
-  } catch (error: any) {
+  } catch (error     ) {
     if (error && (error.code === 'ENOENT' || error.code === 'ENOTDIR' || error.code === 'EISDIR')) {
       return null;
     }
@@ -105,7 +105,7 @@ function readFileIfPresent(filePath: string, fsImpl: any): string | null {
   }
 }
 
-function exists(filePath: string, fsImpl: any): boolean {
+function exists(filePath        , fsImpl     )          {
   try {
     fsImpl.statSync(filePath);
     return true;
@@ -119,7 +119,7 @@ function exists(filePath: string, fsImpl: any): boolean {
  * workspace usually works and occasionally installs a second, divergent `node_modules`.
  * @returns {{ run: string, test: string, manager: string }}
  */
-function nodePackageManager(root: string, fsImpl: any): { run: string; test: string; manager: string } {
+function nodePackageManager(root        , fsImpl     )                                                 {
   if (exists(path.join(root, 'pnpm-lock.yaml'), fsImpl)) {
     return { run: 'pnpm run', test: 'pnpm test', manager: 'pnpm' };
   }
@@ -135,14 +135,14 @@ function nodePackageManager(root: string, fsImpl: any): { run: string; test: str
 /**
  * @returns {{ id: string, roles: Object, absent: Array<string> }|null}
  */
-function detectNode(root: string, fsImpl: any): any {
+function detectNode(root        , fsImpl     )      {
   const raw = readFileIfPresent(path.join(root, 'package.json'), fsImpl);
   if (raw === null) return null;
 
-  let pkg: any;
+  let pkg     ;
   try {
     pkg = JSON.parse(raw);
-  } catch (error: any) {
+  } catch (error     ) {
     // A malformed manifest is not an absent manifest. Reporting it as "no build script" would
     // hand the caller a confident answer derived from a file it failed to read.
     return { id: 'package.json', roles: {}, absent: [], error: `package.json is not valid JSON: ${error.message}` };
@@ -150,14 +150,14 @@ function detectNode(root: string, fsImpl: any): any {
 
   const scripts = (pkg && typeof pkg.scripts === 'object' && pkg.scripts) || {};
   const pm = nodePackageManager(root, fsImpl);
-  const roles: Record<string, any> = {};
+  const roles                      = {};
   // Node has no project-wide parse step distinct from type-checking or running the code; `node
   // --check` needs an explicit file list this module does not have. Reporting it absent (rather
   // than leaving it undetected) lets the parse tier resolve NOT_APPLICABLE instead of stalling
   // every contract in every plain-JavaScript repository on a step that does not exist.
-  const absent: string[] = ['parse'];
+  const absent           = ['parse'];
 
-  const script = (...names: string[]) => names.find((n) => typeof scripts[n] === 'string' && scripts[n].trim() !== '');
+  const script = (...names          ) => names.find((n) => typeof scripts[n] === 'string' && scripts[n].trim() !== '');
 
   const buildScript = script('build');
   if (buildScript) roles.build = { command: `${pm.run} ${buildScript}`, derivation: 'declared' };
@@ -180,7 +180,7 @@ function detectNode(root: string, fsImpl: any): any {
     const testText = scripts[testScript].trim();
     const scriptArgs = testText.split(' ').slice(2);
     // A flag (`--require ./setup.js`) would be dropped by the targeted form, so it is not declared.
-    if (NODE_TEST_SCRIPT.test(testText) && !SHELL_SYNTAX.test(testText) && !scriptArgs.some((arg: string) => arg.startsWith('-'))) {
+    if (NODE_TEST_SCRIPT.test(testText) && !SHELL_SYNTAX.test(testText) && !scriptArgs.some((arg        ) => arg.startsWith('-'))) {
       // The runner is named by the script itself, so the targeted form is declared, not guessed.
       // `testDirs` are the roots the script's arguments name: where its test files live. A quoted
       // argument loses its quotes and a glob keeps only the path before its first glob segment.
@@ -197,7 +197,7 @@ function detectNode(root: string, fsImpl: any): any {
   return { id: 'package.json', roles, absent };
 }
 
-function detectRust(root: string, fsImpl: any): any {
+function detectRust(root        , fsImpl     )      {
   if (!exists(path.join(root, 'Cargo.toml'), fsImpl)) return null;
   return {
     id: 'Cargo.toml',
@@ -212,7 +212,7 @@ function detectRust(root: string, fsImpl: any): any {
   };
 }
 
-function detectGo(root: string, fsImpl: any): any {
+function detectGo(root        , fsImpl     )      {
   if (!exists(path.join(root, 'go.mod'), fsImpl)) return null;
   return {
     id: 'go.mod',
@@ -231,13 +231,13 @@ function detectGo(root: string, fsImpl: any): any {
  * dependency for tool-table presence detection is not worth it. Only the presence of a `[tool.X]`
  * table is used, which is robust to the parts of TOML this does not understand.
  */
-function detectPython(root: string, fsImpl: any): any {
+function detectPython(root        , fsImpl     )      {
   const raw = readFileIfPresent(path.join(root, 'pyproject.toml'), fsImpl);
   if (raw === null) return null;
 
-  const hasTable = (name: string) => new RegExp(`^\\s*\\[tool\\.${name}[\\].]`, 'm').test(raw);
-  const roles: Record<string, any> = {};
-  const absent: string[] = [];
+  const hasTable = (name        ) => new RegExp(`^\\s*\\[tool\\.${name}[\\].]`, 'm').test(raw);
+  const roles                      = {};
+  const absent           = [];
 
   if (hasTable('pytest') || exists(path.join(root, 'pytest.ini'), fsImpl) || exists(path.join(root, 'tests'), fsImpl)) {
     roles.test = { command: 'pytest', derivation: 'inferred' };
@@ -259,7 +259,7 @@ function detectPython(root: string, fsImpl: any): any {
 }
 
 /** Makefile target name → the role it serves. Only unambiguous names are mapped. */
-const MAKE_TARGET_ROLES: Readonly<Record<string, string>> = Object.freeze({
+const MAKE_TARGET_ROLES                                   = Object.freeze({
   build: 'build',
   compile: 'build',
   test: 'test',
@@ -271,14 +271,14 @@ const MAKE_TARGET_ROLES: Readonly<Record<string, string>> = Object.freeze({
   check: 'parse',
 });
 
-function detectMake(root: string, fsImpl: any): any {
+function detectMake(root        , fsImpl     )      {
   const raw = readFileIfPresent(path.join(root, 'Makefile'), fsImpl) ??
     readFileIfPresent(path.join(root, 'makefile'), fsImpl);
   if (raw === null) return null;
 
-  const roles: Record<string, any> = {};
-  const absent: string[] = [];
-  const targets = new Set<string>();
+  const roles                      = {};
+  const absent           = [];
+  const targets = new Set        ();
   // Target lines only: a leading tab means a recipe line, and `:=` is a variable assignment.
   for (const line of raw.split('\n')) {
     const m = /^([A-Za-z0-9_.\-/]+)\s*:(?!=)/.exec(line);
@@ -302,7 +302,7 @@ function detectMake(root: string, fsImpl: any): any {
  * and a repository where it is the real entrypoint is precisely the case the `plan.md` override
  * exists for.
  */
-const DETECTORS: readonly ((root: string, fsImpl: any) => any)[] = Object.freeze([detectNode, detectRust, detectGo, detectPython, detectMake]);
+const DETECTORS                                                  = Object.freeze([detectNode, detectRust, detectGo, detectPython, detectMake]);
 
 /**
  * Extracts the override object from a feature's `plan.md`.
@@ -312,25 +312,25 @@ const DETECTORS: readonly ((root: string, fsImpl: any) => any)[] = Object.freeze
  * @param {string} planText
  * @returns {{ override: Object|null, errors: Array<string> }}
  */
-function parsePlanOverride(planText: any): { override: any; errors: string[] } {
+function parsePlanOverride(planText     )                                      {
   if (typeof planText !== 'string' || planText === '') return { override: null, errors: [] };
 
   const fence = new RegExp(`^[ \\t]*\`\`\`${PLAN_OVERRIDE_BLOCK}[ \\t]*\\n([\\s\\S]*?)^[ \\t]*\`\`\``, 'm');
   const match = fence.exec(planText);
   if (!match) return { override: null, errors: [] };
 
-  let parsed: any;
+  let parsed     ;
   try {
     parsed = JSON.parse(match[1]);
-  } catch (error: any) {
+  } catch (error     ) {
     return { override: null, errors: [`plan.md '${PLAN_OVERRIDE_BLOCK}' block is not valid JSON: ${error.message}`] };
   }
   if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
     return { override: null, errors: [`plan.md '${PLAN_OVERRIDE_BLOCK}' block must be a JSON object mapping command roles to commands`] };
   }
 
-  const errors: string[] = [];
-  for (const [key, value] of Object.entries(parsed) as [string, any][]) {
+  const errors           = [];
+  for (const [key, value] of Object.entries(parsed)                   ) {
     if (!COMMAND_ROLES.includes(key)) {
       errors.push(`plan.md override declares unknown command role '${key}'; known roles: ${COMMAND_ROLES.join(', ')}`);
       continue;
@@ -362,21 +362,21 @@ function parsePlanOverride(planText: any): { override: any; errors: string[] } {
  *   errors: Array<string>
  * }}
  */
-function detectCommands(options: any = {}): any {
+function detectCommands(options      = {})      {
   const fsImpl = options.fsImpl || fs;
   const projectRoot = options.projectRoot || process.cwd();
 
-  const manifests: string[] = [];
-  const commands: Record<string, any> = {};
-  const alternatives: any[] = [];
-  const absentByRole = new Map<string, string>();
-  const errors: string[] = [];
+  const manifests           = [];
+  const commands                      = {};
+  const alternatives        = [];
+  const absentByRole = new Map                ();
+  const errors           = [];
 
   for (const detector of DETECTORS) {
-    let found: any;
+    let found     ;
     try {
       found = detector(projectRoot, fsImpl);
-    } catch (error: any) {
+    } catch (error     ) {
       errors.push(`Detector failed while reading ${projectRoot}: ${error.message}`);
       continue;
     }
@@ -386,7 +386,7 @@ function detectCommands(options: any = {}): any {
       errors.push(found.error);
       continue;
     }
-    for (const [role, entry] of Object.entries(found.roles) as [string, any][]) {
+    for (const [role, entry] of Object.entries(found.roles)                   ) {
       if (commands[role]) {
         alternatives.push({ role, command: entry.command, source: found.id, derivation: entry.derivation });
       } else {
@@ -401,7 +401,7 @@ function detectCommands(options: any = {}): any {
   // A role another manifest supplied is not absent, whatever the manifest that lacked it said.
   for (const role of Object.keys(commands)) absentByRole.delete(role);
 
-  let planText: any = options.planText;
+  let planText      = options.planText;
   if (typeof planText !== 'string' && options.planPath) {
     planText = readFileIfPresent(options.planPath, fsImpl);
     if (planText === null) {
@@ -410,12 +410,12 @@ function detectCommands(options: any = {}): any {
     }
   }
 
-  const declaredNone: string[] = [];
+  const declaredNone           = [];
   const { override, errors: overrideErrors } = parsePlanOverride(planText);
   errors.push(...overrideErrors);
 
   if (override && overrideErrors.length === 0) {
-    for (const [role, value] of Object.entries(override) as [string, any][]) {
+    for (const [role, value] of Object.entries(override)                   ) {
       if (value === null) {
         delete commands[role];
         absentByRole.delete(role);
@@ -494,7 +494,7 @@ function detectCommands(options: any = {}): any {
  * @param {string} [pattern]
  * @returns {{ command: string, substituted: boolean }}
  */
-function applyTargetPattern(command: any, pattern?: string): { command: string | null; substituted: boolean } {
+function applyTargetPattern(command     , pattern         )                                                   {
   if (typeof command !== 'string' || !command.includes(TARGET_PATTERN_TOKEN)) {
     return { command, substituted: false };
   }

package/src/runtime/{context-pack.ts → context-pack.js}

@@ -2,16 +2,16 @@
 
 // TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
 
-const { EvidenceLedger } = require('./evidence-ledger.ts');
-const { ClaimsManager } = require('./claims.ts');
-const { ResearchRequestStore } = require('./research-request.ts');
-const { finishRuntime, usageError } = require('./cli-result.ts');
-const { resolveActiveFeature } = require('./feature-resolve.ts');
-const { readRegister } = require('./decision-register.ts');
+const { EvidenceLedger } = require('./evidence-ledger.js');
+const { ClaimsManager } = require('./claims.js');
+const { ResearchRequestStore } = require('./research-request.js');
+const { finishRuntime, usageError } = require('./cli-result.js');
+const { resolveActiveFeature } = require('./feature-resolve.js');
+const { readRegister } = require('./decision-register.js');
 
 const NO_DECISIONS = Object.freeze({ available: false, live: [], liveCount: 0 });
 
-const TASK_CLASS_BUDGETS: Record<string, any> = Object.freeze({
+const TASK_CLASS_BUDGETS                      = Object.freeze({
   feature: 225000,
   'dependency-change': 85000,
   bug: 71000,
@@ -32,23 +32,23 @@ const TASK_CLASS_BUDGETS: Record<string, any> = Object.freeze({
  * @param {{projectRoot:string, slug?:string|null}} options
  * @returns {{available:boolean, live:Array<Object>, liveCount:number, reason?:string}}
  */
-function loadLiveDecisions({ projectRoot, slug = null }: any) {
+function loadLiveDecisions({ projectRoot, slug = null }     ) {
   try {
     const feature = resolveActiveFeature({ projectRoot, slug });
     if (feature.error) return { ...NO_DECISIONS };
     let register;
     try {
       register = readRegister(feature.featureDir);
-    } catch (error: any) {
+    } catch (error     ) {
       // The register exists but cannot be trusted. Stay unavailable, but say why, so a stage
       // sees the corruption instead of reading "no decisions".
       return { ...NO_DECISIONS, reason: `register unreadable: ${error.message}` };
     }
     if (!register) return { ...NO_DECISIONS };
     const live = register.decisions
-      .filter((d: any) => d.status === 'live')
-      .sort((a: any, b: any) => (a.topic < b.topic ? -1 : a.topic > b.topic ? 1 : 0))
-      .map(({ id, topic, statement, decidedBy, stage }: any) => ({ id, topic, statement, decidedBy, stage }));
+      .filter((d     ) => d.status === 'live')
+      .sort((a     , b     ) => (a.topic < b.topic ? -1 : a.topic > b.topic ? 1 : 0))
+      .map(({ id, topic, statement, decidedBy, stage }     ) => ({ id, topic, statement, decidedBy, stage }));
     return { available: true, live, liveCount: live.length };
   } catch {
     return { ...NO_DECISIONS };
@@ -56,14 +56,14 @@ function loadLiveDecisions({ projectRoot, slug = null }: any) {
 }
 
 class ContextPackCompiler {
-  declare options: any;
+                       
   /**
    * @param {Object} [defaultOptions]
    * @param {number} [defaultOptions.maxFiles=15]
    * @param {number} [defaultOptions.maxClaims=20]
    * @param {number} [defaultOptions.maxEvidenceItems=25]
    */
-  constructor(defaultOptions: any = {}) {
+  constructor(defaultOptions      = {}) {
     this.options = {
       maxFiles: defaultOptions.maxFiles || 15,
       maxClaims: defaultOptions.maxClaims || 20,
@@ -85,7 +85,7 @@ class ContextPackCompiler {
    * @param {Object} [budgetOverrides={}]
    * @returns {Object} ContextPack
    */
-  compileContextPack(params: any, budgetOverrides: any = {}) {
+  compileContextPack(params     , budgetOverrides      = {}) {
     const {
       taskId,
       taskClass = 'feature',
@@ -204,7 +204,7 @@ class ContextPackCompiler {
    * @param {Object} pack
    * @returns {string}
    */
-  formatMarkdown(pack: any) {
+  formatMarkdown(pack     ) {
     let md = `## ContextPack: [${pack.taskClass.toUpperCase()}] ${pack.taskId}\n`;
     if (pack.objective) {
       md += `**Objective:** ${pack.objective}\n\n`;
@@ -271,7 +271,7 @@ class ContextPackCompiler {
    * @param {Array<string>} [options.optional.unverifiedClaims]
    * @returns {Object} ContextPackResult
    */
-  compileBoundedContextPack(options: any = {}) {
+  compileBoundedContextPack(options      = {}) {
     const {
       taskId = 'default',
       taskClass = 'feature',
@@ -351,7 +351,7 @@ class ContextPackCompiler {
     const keptNarrative = [];
     const omissions = [];
 
-    const buildPayload = (hList: any, cList: any, nList: any) => {
+    const buildPayload = (hList     , cList     , nList     ) => {
       let md = mandatoryMd;
       if (hList.length > 0) {
         md += `### Active Hypotheses (Unverified)\n`;
@@ -424,7 +424,7 @@ class ContextPackCompiler {
   /**
    * Alias for compileBoundedContextPack.
    */
-  compileBoundedPayload(options: any = {}) {
+  compileBoundedPayload(options      = {}) {
     return this.compileBoundedContextPack(options);
   }
 }
@@ -446,7 +446,7 @@ class ContextPackCompiler {
  * @param {string} [options.slug] feature slug, when the task id is not the feature's own
  * @returns {number} exit code
  */
-function handleContextPackCommand({ taskId, taskClass, objective, json = false, stateRoot, slug }: any = {}) {
+function handleContextPackCommand({ taskId, taskClass, objective, json = false, stateRoot, slug }      = {}) {
   const root = stateRoot || process.cwd();
   const ledger = new EvidenceLedger({ repoRoot: root, slug });
   ledger.load(taskId);