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

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/budget.js

@@ -0,0 +1,203 @@
+'use strict';
+
+// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
+
+const path = require('node:path');
+const fs = require('node:fs');
+const { loadRegistry } = require('../../registry/index.js');
+
+const TASK_CLASS_BUDGETS                         = Object.freeze({
+  feature: 225000,
+  'dependency-change': 85000,
+  bug: 71000,
+  refactor: 71000,
+  documentation: 57000,
+  operations: 45000,
+  review: 42000,
+  research: 35302,
+  'trivial-edit': 30000,
+});
+
+let cachedHarnesses      = null;
+let cachedHarnessIds                  = null;
+let registryLoadCount         = 0;
+
+function clearRegistryCache()       {
+  cachedHarnesses = null;
+  cachedHarnessIds = null;
+  cachedBudgetsJson = null;
+}
+
+function getRegistryLoadCount()         {
+  return registryLoadCount;
+}
+
+function getRegisteredHarnesses()      {
+  if (cachedHarnesses) return cachedHarnesses;
+  registryLoadCount++;
+  const repoRoot = path.resolve(__dirname, '../../../');
+  const harnessesPath = path.join(repoRoot, 'core', 'registry', 'harnesses.json');
+  try {
+    const raw = JSON.parse(fs.readFileSync(harnessesPath, 'utf8'));
+    if (Array.isArray(raw?.harnesses)) {
+      cachedHarnesses = raw.harnesses;
+      return cachedHarnesses;
+    }
+  } catch {
+    // fallback if unreadable
+  }
+  cachedHarnesses = loadRegistry({ repoRoot }).harnesses;
+  return cachedHarnesses;
+}
+
+function getRegisteredHarnessIds()           {
+  if (cachedHarnessIds && cachedHarnesses) return cachedHarnessIds;
+  const ids = getRegisteredHarnesses().map((h     ) => h.id);
+  cachedHarnessIds = ids;
+  return ids;
+}
+
+let cachedBudgetsJson      = null;
+
+function getBudgetsJson()      {
+  if (cachedBudgetsJson) return cachedBudgetsJson;
+  try {
+    const budgetsPath = path.resolve(__dirname, '../../../bench/perf/budgets.json');
+    if (fs.existsSync(budgetsPath)) {
+      cachedBudgetsJson = JSON.parse(fs.readFileSync(budgetsPath, 'utf8'));
+      return cachedBudgetsJson;
+    }
+  } catch {
+    // fallback if unreadable
+  }
+  return null;
+}
+
+/**
+ * Resolves budget and harness identity per IC-012.
+ * Precedence:
+ * 1. Harness identity: flag -> env (DOFLOW_AGENT) -> unstated
+ * 2. Cap: override (--max-bytes) -> profile -> task-class
+ * 3. Capacity: declared -> unknown
+ */
+function resolveBudget({
+  taskClass = 'feature',
+  maxBytes,
+  harnessFlag = null,
+  env = process.env,
+  profiles = null,
+  budgetsJson = null,
+}      = {})      {
+  const harnesses = profiles || getRegisteredHarnesses();
+  const validIds = harnesses.map((h     ) => h.id);
+
+  // 1. Harness identity
+  let harness                                                                            ;
+
+  if (harnessFlag !== null && harnessFlag !== undefined && harnessFlag !== '') {
+    if (!validIds.includes(harnessFlag)) {
+      const err      = new Error(`Unknown harness '${harnessFlag}'. Valid harnesses: ${validIds.join(', ')}`);
+      err.code = 'USAGE_ERROR';
+      err.validIds = validIds;
+      throw err;
+    }
+    harness = { id: harnessFlag, source: 'flag' };
+  } else if (env && env.DOFLOW_AGENT) {
+    const agentEnv = env.DOFLOW_AGENT;
+    if (validIds.includes(agentEnv)) {
+      harness = { id: agentEnv, source: 'env' };
+    } else {
+      harness = { id: null, source: 'unstated', basis: 'env-unregistered' };
+    }
+  } else {
+    harness = { id: null, source: 'unstated' };
+  }
+
+  // Find harness declaration for profile lookup
+  const harnessObj = harness.id ? harnesses.find((h     ) => h.id === harness.id) : null;
+  const contextProfile = harnessObj?.contextProfile;
+
+  // Capacity & Tool Limit
+  let capacity                                         ;
+  let toolResultLimitBytes                = null;
+
+  if (!harness.id) {
+    capacity = { value: null, basis: 'unknown:harness-unstated' };
+  } else if (contextProfile?.capacityTokens && typeof contextProfile.capacityTokens.value === 'number') {
+    capacity = {
+      value: contextProfile.capacityTokens.value,
+      basis: `declared:${contextProfile.capacityTokens.source || 'profile'}`,
+    };
+  } else if (contextProfile?.capacityTokens?.unverified) {
+    capacity = {
+      value: null,
+      basis: `unknown:${contextProfile.capacityTokens.unverified}`,
+    };
+  } else {
+    capacity = {
+      value: null,
+      basis: 'unknown:profile-value-unavailable',
+    };
+  }
+
+  if (contextProfile?.toolResultLimitBytes && typeof contextProfile.toolResultLimitBytes.value === 'number') {
+    toolResultLimitBytes = contextProfile.toolResultLimitBytes.value;
+  }
+
+  // 2. Cap resolution
+  let resolvedMaxBytes        ;
+  let source                                       ;
+  let startupTokens                                          = null;
+
+  if (Number.isInteger(maxBytes) && maxBytes > 0) {
+    resolvedMaxBytes = maxBytes;
+    source = 'override';
+  } else if (
+    contextProfile?.capacityTokens &&
+    typeof contextProfile.capacityTokens.value === 'number' &&
+    contextProfile?.reserveTokens &&
+    typeof contextProfile.reserveTokens.value === 'number'
+  ) {
+    // Profile available calculation: (capacity - startup - reserve) * 4
+    const effectiveBudgets = budgetsJson !== null && budgetsJson !== undefined ? budgetsJson : getBudgetsJson();
+    let startupTokensEstimate = 0;
+    let startupTokensBasis = 'unmeasured:no-entry';
+    if (effectiveBudgets?.startupContext && Array.isArray(effectiveBudgets.startupContext)) {
+      const entry = effectiveBudgets.startupContext.find((s     ) => s.harness === harness.id);
+      if (typeof entry?.tokensEst === 'number') {
+        startupTokensEstimate = entry.tokensEst;
+        startupTokensBasis = entry.tokensBasis || 'estimated:bytes/4';
+      } else if (entry?.sessionStartStdoutBytes?.unmeasured) {
+        startupTokensBasis = `unmeasured:${entry.sessionStartStdoutBytes.unmeasured}`;
+      }
+    }
+    startupTokens = {
+      value: startupTokensEstimate,
+      basis: startupTokensBasis,
+    };
+    const available = (contextProfile.capacityTokens.value - startupTokensEstimate - contextProfile.reserveTokens.value) * 4;
+    resolvedMaxBytes = Math.max(0, available);
+    source = 'profile';
+  } else {
+    resolvedMaxBytes = TASK_CLASS_BUDGETS[taskClass] || 225000;
+    source = 'task-class';
+  }
+
+  return {
+    maxBytes: resolvedMaxBytes,
+    source,
+    harness,
+    capacity,
+    toolResultLimitBytes,
+    ...(startupTokens ? { startupTokens } : {}),
+  };
+}
+
+module.exports = {
+  TASK_CLASS_BUDGETS,
+  resolveBudget,
+  getRegisteredHarnessIds,
+  getRegisteredHarnesses,
+  clearRegistryCache,
+  getRegistryLoadCount,
+};