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

package/src/runtime/verification/{registry.ts → registry.js}

@@ -14,8 +14,8 @@
 
 const path = require('node:path');
 const nodeFs = require('node:fs');
-const { parseYamlFile } = require('../capability-router.ts');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
+const { parseYamlFile } = require('../capability-router.js');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
 
 const REGISTRY_FILENAME = 'verification.json';
 
@@ -48,7 +48,7 @@ const RECOVERY_OUTCOMES = Object.freeze([
   'NO_REMEDIATION',
 ]);
 
-function assert(condition: any, message: string): void {
+function assert(condition     , message        )       {
   if (!condition) throw new Error(`verification.json is invalid: ${message}`);
 }
 
@@ -67,7 +67,7 @@ function assert(condition: any, message: string): void {
  * @param {Object} [options.fsImpl]
  * @returns {Object} the validated registry
  */
-function loadVerificationRegistry(options: any = {}): any {
+function loadVerificationRegistry(options      = {})      {
   let data = options.registry;
   if (!data) {
     const repoRoot = options.repoRoot || REPO_ROOT;
@@ -84,7 +84,7 @@ function loadVerificationRegistry(options: any = {}): any {
   // FR-009 states this as a MUST, so it is enforced at load rather than trusted at call sites.
   assert(policy.modelReviewIsPrimaryProof === false, 'policy.modelReviewIsPrimaryProof must be false');
 
-  const seen = new Set<string>();
+  const seen = new Set        ();
   let previousOrder = -Infinity;
   let lastNonModelOrder = -Infinity;
   let firstModelOrder = Infinity;
@@ -107,7 +107,7 @@ function loadVerificationRegistry(options: any = {}): any {
   // of the registry, so it is checkable here instead of being re-asserted in prose.
   assert(firstModelOrder > lastNonModelOrder, 'every model-based tier must be ordered after every deterministic tier');
 
-  for (const [level, def] of Object.entries(data.riskLevels) as [string, any][]) {
+  for (const [level, def] of Object.entries(data.riskLevels)                   ) {
     assert(def && Array.isArray(def.requiredTiers), `risk level '${level}' needs requiredTiers`);
     for (const id of def.requiredTiers.concat(def.advisoryTiers || [])) {
       assert(seen.has(id), `risk level '${level}' references unknown tier '${id}'`);

package/src/runtime/verification/{scope-bound.ts → scope-bound.js}

@@ -5,9 +5,9 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
-const { resolveActiveFeature } = require('../feature-resolve.ts');
-const { resolveBashHelper } = require('../../helper/bash-helper.ts');
-const { listCheckouts } = require('../checkouts.ts');
+const { resolveActiveFeature } = require('../feature-resolve.js');
+const { resolveBashHelper } = require('../../helper/bash-helper.js');
+const { listCheckouts } = require('../checkouts.js');
 
 // The change-scope bound of a planned feature, and the baseline a change is measured from
 // (feature 045, IC-003 / IC-004).
@@ -36,13 +36,13 @@ const NONE_FIELD = /^none(?=$|[\s(;,`])/i;
  * @param {string} planText
  * @returns {Array<string>}
  */
-function taskFilesFromPlan(planText: any): string[] {
+function taskFilesFromPlan(planText     )           {
   const lines = String(planText || '').split('\n');
-  const paths: string[] = [];
+  const paths           = [];
   for (let i = 0; i < lines.length; i += 1) {
     if (!TASK_LINE.test(lines[i])) continue;
     let at = -1;
-    for (const m of lines[i].matchAll(FILES_FIELD)) at = (m.index as number) + m[0].length;
+    for (const m of lines[i].matchAll(FILES_FIELD)) at = (m.index          ) + m[0].length;
     if (at === -1) continue;
     let rest = lines[i].slice(at);
     // `files: none (...)` states that a task changes no file; its words are not paths.
@@ -65,9 +65,9 @@ function taskFilesFromPlan(planText: any): string[] {
   return [...new Set(paths)];
 }
 
-const folderOf = (slug: string | null) => (slug ? `agent-docs/doflow/${slug}/` : null);
+const folderOf = (slug               ) => (slug ? `agent-docs/doflow/${slug}/` : null);
 
-function isFile(file: string): boolean {
+function isFile(file        )          {
   try {
     return fs.statSync(file).isFile();
   } catch {
@@ -75,7 +75,7 @@ function isFile(file: string): boolean {
   }
 }
 
-function isDirectory(dir: string): boolean {
+function isDirectory(dir        )          {
   try {
     return fs.statSync(dir).isDirectory();
   } catch {
@@ -84,7 +84,7 @@ function isDirectory(dir: string): boolean {
 }
 
 /** Why no other checkout was consulted, in the words a reason text lists. */
-function noMainCheckout(checkouts: any): string {
+function noMainCheckout(checkouts     )         {
   if (!checkouts.ok) {
     if (checkouts.reason === 'not-a-git-repository') return 'not a git repository';
     if (checkouts.reason === 'git-unavailable') return 'git is not available';
@@ -110,20 +110,20 @@ function noMainCheckout(checkouts: any): string {
  * @returns {{plan: string|null, planRel: string|null, origin: string|null, root: string|null, slug: string|null,
  *   folderRel: string|null, hasRegister: boolean, searched: Array<{place: string, result: string}>, reason: string|null}}
  */
-function resolvePlanSource({ projectRoot, slug = null, planPath = null, exec = spawnSync }: {
-  projectRoot: string;
-  slug?: string | null;
-  planPath?: string | null;
-  exec?: any;
-}): any {
-  const searched: any[] = [];
-  const result = (fields: any) => ({
+function resolvePlanSource({ projectRoot, slug = null, planPath = null, exec = spawnSync }   
+                      
+                       
+                           
+             
+ )      {
+  const searched        = [];
+  const result = (fields     ) => ({
     plan: null, planRel: null, origin: null, root: null, slug: null, folderRel: null, hasRegister: false, searched, reason: null, ...fields,
   });
-  const resolve = (s: string | null) => {
+  const resolve = (s               ) => {
     try {
       return resolveActiveFeature({ projectRoot, slug: s });
-    } catch (error: any) {
+    } catch (error     ) {
       return { error: 'resolver-failed', message: `could not run the feature resolver: ${error.message}` };
     }
   };
@@ -151,7 +151,7 @@ function resolvePlanSource({ projectRoot, slug = null, planPath = null, exec = s
   }
   const s = found.paths.feature_slug;
   const folderRel = folderOf(s);
-  const withFolder = (fields: any) => {
+  const withFolder = (fields     ) => {
     const plan = path.resolve(fields.root, fields.planRel);
     let reason = null;
     if (!isFile(plan)) reason = 'no-plan';
@@ -182,7 +182,7 @@ function resolvePlanSource({ projectRoot, slug = null, planPath = null, exec = s
 }
 
 /** Why a declared-scope token is refused, or null when it is a repository-relative path. */
-function refusedToken(token: string): string | null {
+function refusedToken(token        )                {
   if (token === '') return 'it is empty';
   if (/[\s\\\0]/.test(token)) return 'it contains whitespace';
   if (token.startsWith('/') || token.startsWith('~') || /^[A-Za-z]:/.test(token)) return 'it is absolute';
@@ -200,8 +200,8 @@ function refusedToken(token: string): string | null {
  * @param {string} text
  * @returns {{paths: Array<string>, reason: null}|{paths: null, reason: string}}
  */
-function parseDeclaredScope(text: any): any {
-  const paths: string[] = [];
+function parseDeclaredScope(text     )      {
+  const paths           = [];
   for (const raw of String(text).trim().split(',')) {
     const written = raw.trim();
     const token = written.replace(/^(\.\/)+/, '');
@@ -225,20 +225,20 @@ function parseDeclaredScope(text: any): any {
  * @param {Function} [options.exec]
  * @returns {{bound: Object|null, reason: string|null, searched: Array<Object>, planSource: Object}}
  */
-function resolveScopeBound({ projectRoot, slug = null, planPath = null, declared = null, baselineRef = null, exec = spawnSync }: {
-  projectRoot: string;
-  slug?: string | null;
-  planPath?: string | null;
-  declared?: any;
-  baselineRef?: string | null;
-  exec?: any;
-}): any {
+function resolveScopeBound({ projectRoot, slug = null, planPath = null, declared = null, baselineRef = null, exec = spawnSync }   
+                      
+                       
+                           
+                 
+                              
+             
+ )      {
   const planSource = resolvePlanSource({ projectRoot, slug, planPath, exec });
   let reason = planSource.reason;
-  const allowed: string[] = [];
-  const sources: any[] = [];
+  const allowed           = [];
+  const sources        = [];
   if (reason === null) {
-    let text: string | null = null;
+    let text                = null;
     try {
       text = fs.readFileSync(planSource.plan, 'utf8');
     } catch {
@@ -257,7 +257,7 @@ function resolveScopeBound({ projectRoot, slug = null, planPath = null, declared
     sources.push({ kind: 'declared', paths: [...declared.paths], origin: declared.origin, ...(declared.record ? { record: declared.record } : {}) });
   }
 
-  let baseline: any = null;
+  let baseline      = null;
   if (baselineRef !== null && baselineRef !== undefined) {
     const res = resolveExplicitBaseline({ cwd: projectRoot, ref: baselineRef, exec });
     if (!res.ok) {
@@ -294,12 +294,12 @@ function resolveScopeBound({ projectRoot, slug = null, planPath = null, declared
  * @param {string|null} [options.slug]
  * @returns {{allowedPaths: Array<string>, source: string}|null}
  */
-function buildScopeBound({ projectRoot, slug = null }: { projectRoot: string; slug?: string | null }): any {
+function buildScopeBound({ projectRoot, slug = null }                                               )      {
   const { bound } = resolveScopeBound({ projectRoot, slug });
   return bound ? { allowedPaths: bound.allowedPaths, source: bound.source } : null;
 }
 
-function originText(origin: string | null, root: string | null): string {
+function originText(origin               , root               )         {
   if (origin === 'main-checkout') return `main checkout ${root}`;
   if (origin === 'plan-path') return '--plan-path';
   return 'current checkout';
@@ -314,8 +314,8 @@ function originText(origin: string | null, root: string | null): string {
  * @param {Object} options.planSource the `resolvePlanSource` result
  * @returns {string}
  */
-function scopeReasonText({ reason, taskId, planSource }: { reason: string; taskId: string; planSource: any }): string {
-  const places = planSource.searched.map((s: any) => `${s.place}: ${s.result}`).join('; ');
+function scopeReasonText({ reason, taskId, planSource }                                                     )         {
+  const places = planSource.searched.map((s     ) => `${s.place}: ${s.result}`).join('; ');
   const where = `${planSource.folderRel} (${originText(planSource.origin, planSource.root)})`;
   switch (reason) {
     case 'no-plan':
@@ -336,8 +336,8 @@ function scopeReasonText({ reason, taskId, planSource }: { reason: string; taskI
  * @param {Array<Object>} sources a bound's `sources`
  * @returns {string}
  */
-function boundSourcesText(sources: any[]): string {
-  return sources.map((s: any) => (s.kind === 'plan'
+function boundSourcesText(sources       )         {
+  return sources.map((s     ) => (s.kind === 'plan'
     ? `plan ${s.path} (${originText(s.origin, s.root)})`
     : `declared ${s.paths.join(',')} (${s.origin === 'readiness-record' ? `readiness record ${s.record}` : '--scope'})`)).join(' + ');
 }
@@ -351,17 +351,17 @@ function boundSourcesText(sources: any[]): string {
  * @param {Function} [options.exec] spawnSync-compatible
  * @returns {{ref: string, mergeBase: string}|{reason: string}}
  */
-function resolveIntegrationBase({ cwd, exec = spawnSync }: { cwd: string; exec?: any }): any {
-  const run = (cmd: string, args: string[]) => {
+function resolveIntegrationBase({ cwd, exec = spawnSync }                             )      {
+  const run = (cmd        , args          ) => {
     try {
       return exec(cmd, args, { cwd, encoding: 'utf8', timeout: 30000 });
-    } catch (error: any) {
+    } catch (error     ) {
       return { error };
     }
   };
   const gitState = resolveBashHelper('do-git-state.sh');
   const state = gitState ? run('bash', [gitState, '--json']) : null;
-  let ref: string | null = null;
+  let ref                = null;
   if (state && !state.error && state.status === 0) {
     try { ref = JSON.parse(state.stdout).integration_ref || null; } catch { /* reported below */ }
   }
@@ -386,13 +386,13 @@ function resolveIntegrationBase({ cwd, exec = spawnSync }: { cwd: string; exec?:
  * @param {Function} [options.exec] spawnSync-compatible
  * @returns {{ok: true, ref: string, sha: string}|{ok: false, ref: string, reason: string}}
  */
-function resolveExplicitBaseline({ cwd, ref, exec = spawnSync }: { cwd: string; ref: string; exec?: any }): any {
-  const fail = (reason: string) => ({ ok: false, ref, reason });
+function resolveExplicitBaseline({ cwd, ref, exec = spawnSync }                                          )      {
+  const fail = (reason        ) => ({ ok: false, ref, reason });
   if (typeof ref !== 'string' || ref.trim() === '' || ref.startsWith('-')) {
     return fail(`baseline ref '${ref}' is not a usable commit or ref`);
   }
-  const run = (args: string[]) => {
-    try { return exec('git', args, { cwd, encoding: 'utf8', timeout: 30000 }); } catch (error: any) { return { error }; }
+  const run = (args          ) => {
+    try { return exec('git', args, { cwd, encoding: 'utf8', timeout: 30000 }); } catch (error     ) { return { error }; }
   };
   const parsed = run(['rev-parse', '--verify', '--quiet', '--end-of-options', `${ref}^{commit}`]);
   const sha = parsed && !parsed.error && parsed.status === 0 ? String(parsed.stdout || '').trim() : '';

package/src/runtime/verification/{test-selection.ts → test-selection.js}

@@ -40,18 +40,18 @@ const WIN32_UNQUOTABLE = /[%!]/;
  * @param {string} [platform]
  * @returns {string}
  */
-function quotePath(file: string, platform: string = process.platform): string {
+function quotePath(file        , platform         = process.platform)         {
   if (SAFE_WORD.test(file)) return file;
   if (platform === 'win32') return `"${file.replace(/"/g, '""')}"`;
   return `'${file.replace(/'/g, `'\\''`)}'`;
 }
 
 /** Normalises a repository-relative path: forward slashes, no leading `./`, no trailing `/`. */
-function normalize(file: any): string {
+function normalize(file     )         {
   return String(file).replace(/\\/g, '/').replace(/^(?:\.\/)+/, '').replace(/\/+$/, '');
 }
 
-function statOf(fsImpl: any, file: string): any {
+function statOf(fsImpl     , file        )      {
   try {
     return fsImpl.statSync(file);
   } catch {
@@ -60,14 +60,14 @@ function statOf(fsImpl: any, file: string): any {
 }
 
 /** Repository-relative paths of every file under `rel` (a file counts as itself). */
-function walkFiles(fsImpl: any, root: string, rel: string): string[] {
+function walkFiles(fsImpl     , root        , rel        )           {
   const abs = path.join(root, rel);
   const stat = statOf(fsImpl, abs);
   if (!stat) return [];
   if (stat.isFile()) return [normalize(rel)];
   if (!stat.isDirectory()) return [];
-  const out: string[] = [];
-  let entries: any[];
+  const out           = [];
+  let entries       ;
   try {
     entries = fsImpl.readdirSync(abs, { withFileTypes: true });
   } catch {
@@ -88,19 +88,19 @@ function walkFiles(fsImpl: any, root: string, rel: string): string[] {
  * @param {{ source?: string, testDirs?: Array<string> }} found the detected `testTargeted` entry
  * @returns {null|{ basis: string, isTest: Function, roots: Array<string>, guardDir: string|null }}
  */
-function conventionFor(found: any): any {
+function conventionFor(found     )      {
   if (found && found.source === 'package.json' && Array.isArray(found.testDirs) && found.testDirs.length > 0) {
     const roots = found.testDirs.map(normalize).filter(Boolean);
-    const underRoot = (file: string) => roots.some((r: string) => file === r || file.startsWith(`${r}/`));
+    const underRoot = (file        ) => roots.some((r        ) => file === r || file.startsWith(`${r}/`));
     return {
       basis: 'changed-test-files',
       roots,
-      isTest: (file: string) => NODE_TEST_FILE.test(file) && underRoot(file),
-      guardDir: roots.some((r: string) => GUARD_DIR === r || GUARD_DIR.startsWith(`${r}/`)) ? GUARD_DIR : null,
+      isTest: (file        ) => NODE_TEST_FILE.test(file) && underRoot(file),
+      guardDir: roots.some((r        ) => GUARD_DIR === r || GUARD_DIR.startsWith(`${r}/`)) ? GUARD_DIR : null,
     };
   }
   if (found && found.source === 'pyproject.toml') {
-    return { basis: 'changed-test-files', roots: ['.'], isTest: (file: string) => PYTEST_FILE.test(file), guardDir: null };
+    return { basis: 'changed-test-files', roots: ['.'], isTest: (file        ) => PYTEST_FILE.test(file), guardDir: null };
   }
   return null;
 }
@@ -116,22 +116,22 @@ function conventionFor(found: any): any {
  * @returns {null|{ pattern: string|null, selection: { basis: string, selectedCount: number|null,
  *   totalCount: number|null, fallback: string|null } }} null when no convention applies to the toolchain
  */
-function selectChangedTests({ found, observation, root, fsImpl = nodeFs, platform = process.platform }: {
-  found: any;
-  observation: any;
-  root: string;
-  fsImpl?: any;
-  platform?: string;
-}): any {
+function selectChangedTests({ found, observation, root, fsImpl = nodeFs, platform = process.platform }   
+             
+                   
+               
+               
+                    
+ )      {
   const convention = conventionFor(found);
   if (!convention) return null;
 
-  const total = new Set<string>();
+  const total = new Set        ();
   for (const r of convention.roots) {
     for (const file of walkFiles(fsImpl, root, r)) if (convention.isTest(file)) total.add(file);
   }
   const totalCount = total.size;
-  const fallback = (reason: string, selectedCount: number | null = 0) => ({
+  const fallback = (reason        , selectedCount                = 0) => ({
     pattern: null,
     selection: { basis: convention.basis, selectedCount, totalCount, fallback: reason },
   });
@@ -141,22 +141,22 @@ function selectChangedTests({ found, observation, root, fsImpl = nodeFs, platfor
   const guardDir = convention.guardDir && statOf(fsImpl, path.join(root, convention.guardDir))?.isDirectory()
     ? convention.guardDir
     : null;
-  const underGuard = (file: string) => guardDir !== null && file.startsWith(`${guardDir}/`);
+  const underGuard = (file        ) => guardDir !== null && file.startsWith(`${guardDir}/`);
 
-  const changed = [...new Set<string>(observation.files.map(normalize))]
-    .filter((file: string) => convention.isTest(file))
-    .filter((file: string) => statOf(fsImpl, path.join(root, file))?.isFile())
+  const changed = [...new Set        (observation.files.map(normalize))]
+    .filter((file        ) => convention.isTest(file))
+    .filter((file        ) => statOf(fsImpl, path.join(root, file))?.isFile())
     .sort();
   if (changed.length === 0) return fallback('no-changed-tests');
 
   // A changed guard file is already covered by running the guard directory itself.
-  const files = changed.filter((file: string) => !underGuard(file));
+  const files = changed.filter((file        ) => !underGuard(file));
   const guardFiles = guardDir ? [...total].filter(underGuard).length : 0;
   // `cmd.exe` expands `%` and `!` even inside quotes, so such a path cannot be passed safely there.
-  if (platform === 'win32' && files.some((file: string) => WIN32_UNQUOTABLE.test(file))) return fallback('unsafe-path');
+  if (platform === 'win32' && files.some((file        ) => WIN32_UNQUOTABLE.test(file))) return fallback('unsafe-path');
   // A relative path starting with `-` would be read as a runner option, so it gets a directory prefix.
-  const asArgument = (file: string) => (file.startsWith('-') ? `./${file}` : file);
-  const words = [...files.map((file: string) => quotePath(asArgument(file), platform))];
+  const asArgument = (file        ) => (file.startsWith('-') ? `./${file}` : file);
+  const words = [...files.map((file        ) => quotePath(asArgument(file), platform))];
   if (guardDir) words.push(quotePath(`${guardDir}/`, platform));
   return {
     pattern: words.join(' '),