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

package/src/runtime/trace/{views.ts → views.js}

@@ -20,7 +20,7 @@
 const SESSION_GAP_MS = 30 * 60 * 1000;
 
 /** Nearest-rank percentile over an unsorted numeric array. */
-function percentile(values: number[], fraction: number): number | null {
+function percentile(values          , fraction        )                {
   if (!values.length) return null;
   const sorted = [...values].sort((a, b) => a - b);
   const rank = Math.max(1, Math.ceil(fraction * sorted.length));
@@ -34,31 +34,31 @@ function percentile(values: number[], fraction: number): number | null {
  * @param {number} [options.gapMs=SESSION_GAP_MS]
  * @returns {{grouping: 'session-field'|'idle-gap', sessions: Array<{id: string, startedAt: string|null, endedAt: string|null, records: Object[]}>}}
  */
-function groupSessions(records: any[], { gapMs = SESSION_GAP_MS } = {}): any {
+function groupSessions(records       , { gapMs = SESSION_GAP_MS } = {})      {
   if (!records.length) return { grouping: 'idle-gap', sessions: [] };
 
   // An explicit session id is a recorded fact; an idle gap is an inference. Prefer the fact, and
   // only when every record carries one — a half-labelled history would mix the two silently.
   if (records.every((record) => record.session)) {
-    const order: string[] = [];
-    const byId = new Map<string, any[]>();
+    const order           = [];
+    const byId = new Map               ();
     for (const record of records) {
       if (!byId.has(record.session)) { byId.set(record.session, []); order.push(record.session); }
-      byId.get(record.session)!.push(record);
+      byId.get(record.session) .push(record);
     }
     return {
       grouping: 'session-field',
       sessions: order.map((id) => ({
         id,
-        startedAt: byId.get(id)![0].timestamp,
-        endedAt: byId.get(id)![byId.get(id)!.length - 1].timestamp,
-        records: byId.get(id)!,
+        startedAt: byId.get(id) [0].timestamp,
+        endedAt: byId.get(id) [byId.get(id) .length - 1].timestamp,
+        records: byId.get(id) ,
       })),
     };
   }
 
-  const sessions: any[] = [];
-  let current: any = null;
+  const sessions        = [];
+  let current      = null;
   for (const record of records) {
     const previous = current && current.records[current.records.length - 1];
     const contiguous = previous && record.at !== null && previous.at !== null && record.at - previous.at <= gapMs;
@@ -73,7 +73,7 @@ function groupSessions(records: any[], { gapMs = SESSION_GAP_MS } = {}): any {
 }
 
 /** The ledger provenance every view carries, so a reader can always tell what was actually read. */
-function ledgerSummary(read: any): any {
+function ledgerSummary(read     )      {
   return {
     dir: read.dir,
     exists: read.exists,
@@ -87,8 +87,8 @@ function ledgerSummary(read: any): any {
 
 /** How many records carry each optional field. Every view reports this, because the difference
  * between "no missed opportunities" and "no data to look for them in" is exactly this table. */
-function fieldCoverage(records: any[]): any {
-  const count = (predicate: (r: any) => boolean) => records.filter(predicate).length;
+function fieldCoverage(records       )      {
+  const count = (predicate                     ) => records.filter(predicate).length;
   return {
     capability: count((r) => Boolean(r.capability)),
     provider: count((r) => Boolean(r.provider)),
@@ -108,7 +108,7 @@ function fieldCoverage(records: any[]): any {
  * @param {number} [options.gapMs]
  * @returns {Object} view model
  */
-function buildTrace(read: any, { gapMs = SESSION_GAP_MS } = {}): any {
+function buildTrace(read     , { gapMs = SESSION_GAP_MS } = {})      {
   const ledger = ledgerSummary(read);
   const { grouping, sessions } = groupSessions(read.records, { gapMs });
   if (!sessions.length) {
@@ -126,7 +126,7 @@ function buildTrace(read: any, { gapMs = SESSION_GAP_MS } = {}): any {
   }
 
   const session = sessions[sessions.length - 1];
-  const steps = session.records.map((record: any, index: number) => ({
+  const steps = session.records.map((record     , index        ) => ({
     n: index + 1,
     timestamp: record.timestamp,
     verb: record.verb,
@@ -151,9 +151,9 @@ function buildTrace(read: any, { gapMs = SESSION_GAP_MS } = {}): any {
       startedAt: session.startedAt,
       endedAt: session.endedAt,
       wallDurationMs: start !== null && end !== null ? Math.max(0, end - start) : null,
-      dispatchedMs: steps.reduce((total: number, step: any) => total + (step.durationMs ?? 0), 0),
+      dispatchedMs: steps.reduce((total        , step     ) => total + (step.durationMs ?? 0), 0),
       stepCount: steps.length,
-      failedSteps: steps.filter((step: any) => step.exitCode !== null && step.exitCode !== 0).length,
+      failedSteps: steps.filter((step     ) => step.exitCode !== null && step.exitCode !== 0).length,
       steps,
     },
   };
@@ -166,13 +166,13 @@ function buildTrace(read: any, { gapMs = SESSION_GAP_MS } = {}): any {
  * @param {Object} read result of `RunLedger#read`
  * @returns {Object} view model
  */
-function buildStats(read: any): any {
-  const records: any[] = read.records;
+function buildStats(read     )      {
+  const records        = read.records;
   const ledger = ledgerSummary(read);
   const durations = records.map((r) => r.durationMs).filter((value) => typeof value === 'number');
 
-  const tally = (keyOf: (r: any) => any) => {
-    const map = new Map<string, any>();
+  const tally = (keyOf                 ) => {
+    const map = new Map             ();
     for (const record of records) {
       const key = keyOf(record);
       if (!key) continue;
@@ -221,7 +221,7 @@ function buildStats(read: any): any {
     byVerb: tally((r) => r.verb),
     byCapability: tally((r) => r.capability),
     byProvider: tally((r) => r.provider),
-    byDay: tally((r) => (r.timestamp ? r.timestamp.slice(0, 10) : null)).sort((a: any, b: any) => a.key.localeCompare(b.key)),
+    byDay: tally((r) => (r.timestamp ? r.timestamp.slice(0, 10) : null)).sort((a     , b     ) => a.key.localeCompare(b.key)),
     coverage: fieldCoverage(records),
   };
 }
@@ -230,7 +230,7 @@ function buildStats(read: any): any {
 
 /** Capability ids the opportunity analyses reason about, kept in one place so a registry rename
  * shows up as one edit rather than four scattered string literals. */
-const CAPABILITY: Record<string, string> = Object.freeze({
+const CAPABILITY                         = Object.freeze({
   exactSearch: 'code.exact-search',
   semanticSearch: 'code.semantic-search',
   relationships: 'code.relationships',
@@ -238,7 +238,7 @@ const CAPABILITY: Record<string, string> = Object.freeze({
   compress: 'command.compress',
 });
 
-const PROVIDER: Record<string, string> = Object.freeze({
+const PROVIDER                         = Object.freeze({
   semantic: 'semble.search',
   structural: 'graphify.query',
   compressor: 'rtk',
@@ -260,7 +260,7 @@ const FINDING = 'FINDING';
 const CLEAR = 'CLEAR';
 
 /** Health of a provider as this analysis needs it: only `HEALTHY` counts as "was available". */
-function providerAvailable(providerHealth: any, id: string): boolean | null {
+function providerAvailable(providerHealth     , id        )                 {
   const entry = providerHealth ? providerHealth[id] : undefined;
   if (!entry) return null; // unknown — not the same as unavailable
   return entry.status === 'HEALTHY';
@@ -281,8 +281,8 @@ function providerAvailable(providerHealth: any, id: string): boolean | null {
  * @param {number} [options.gapMs]
  * @returns {Object} view model
  */
-function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_MS } = {}): any {
-  const records: any[] = read.records;
+function buildDiscover(read     , { providerHealth = null, gapMs = SESSION_GAP_MS } = {})      {
+  const records        = read.records;
   const ledger = ledgerSummary(read);
   const coverage = fieldCoverage(records);
   const { grouping, sessions } = groupSessions(records, { gapMs });
@@ -296,7 +296,7 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
       + 'Capability-level records are written by runtime calls that resolve a capability to a provider.',
   };
 
-  const analyses: any[] = [];
+  const analyses        = [];
 
   // 1. A broad search that was really a semantic question.
   analyses.push((() => {
@@ -332,13 +332,13 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
     if (!available) return { ...base, status: NOT_APPLICABLE, detail: `\`${PROVIDER.structural}\` is not answering on this machine, so structural queries were not an available alternative.` };
 
     const offenders = sessions
-      .map((session: any) => ({
+      .map((session     ) => ({
         id: session.id,
         startedAt: session.startedAt,
-        searches: session.records.filter((r: any) => r.capability === CAPABILITY.exactSearch).length,
-        structural: session.records.filter((r: any) => r.capability === CAPABILITY.relationships || r.capability === CAPABILITY.impact).length,
+        searches: session.records.filter((r     ) => r.capability === CAPABILITY.exactSearch).length,
+        structural: session.records.filter((r     ) => r.capability === CAPABILITY.relationships || r.capability === CAPABILITY.impact).length,
       }))
-      .filter((session: any) => session.searches >= REPEATED_SEARCHES && session.structural === 0);
+      .filter((session     ) => session.searches >= REPEATED_SEARCHES && session.structural === 0);
     if (!offenders.length) return { ...base, status: CLEAR, detail: `no session ran ${REPEATED_SEARCHES}+ exact searches without also querying the code graph.` };
     return {
       ...base,
@@ -362,7 +362,7 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
 
     const bulky = records.filter((r) => (r.outputBytes ?? 0) >= LARGE_OUTPUT_BYTES && r.provider !== PROVIDER.compressor);
     if (!bulky.length) return { ...base, status: CLEAR, detail: `no uncompressed run returned ${LARGE_OUTPUT_BYTES} bytes or more.` };
-    const wasted = bulky.reduce((total: number, r: any) => total + r.outputBytes, 0);
+    const wasted = bulky.reduce((total        , r     ) => total + r.outputBytes, 0);
     return {
       ...base,
       status: FINDING,
@@ -379,14 +379,14 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
     const base = { id: 'retries-without-readiness', title: 'Implementation retries with no readiness check beforehand' };
     if (!records.length) return { ...base, status: NOT_DETERMINED, detail: 'the ledger holds no runs to analyse.' };
     const retrying = sessions
-      .map((session: any) => ({
+      .map((session     ) => ({
         id: session.id,
         startedAt: session.startedAt,
-        failedVerifications: session.records.filter((r: any) => r.verb === 'verify' && r.exitCode !== undefined && r.exitCode !== 0).length,
-        recoveries: session.records.filter((r: any) => r.verb === 'recover').length,
-        readinessCalls: session.records.filter((r: any) => r.verb === 'readiness').length,
+        failedVerifications: session.records.filter((r     ) => r.verb === 'verify' && r.exitCode !== undefined && r.exitCode !== 0).length,
+        recoveries: session.records.filter((r     ) => r.verb === 'recover').length,
+        readinessCalls: session.records.filter((r     ) => r.verb === 'readiness').length,
       }))
-      .filter((session: any) => session.failedVerifications >= RETRY_THRESHOLD || session.recoveries >= 1);
+      .filter((session     ) => session.failedVerifications >= RETRY_THRESHOLD || session.recoveries >= 1);
     if (!retrying.length) {
       // The retry signal is a `verify` that FAILED (non-zero exit_code) or a `recover` run. A
       // `verify` record with no exit_code carries neither, and that is the shape the shell
@@ -408,7 +408,7 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
           : 'no `verify` with a recorded exit code and no `recover` run appears in this window, so there is no retry behaviour to judge.',
       };
     }
-    const unguarded = retrying.filter((session: any) => session.readinessCalls === 0);
+    const unguarded = retrying.filter((session     ) => session.readinessCalls === 0);
     if (!unguarded.length) {
       return {
         ...base,
@@ -430,7 +430,7 @@ function buildDiscover(read: any, { providerHealth = null, gapMs = SESSION_GAP_M
   const undetermined = analyses.filter((analysis) => analysis.status === NOT_DETERMINED);
 
   // The verdict never claims a clean bill of health over data that could not answer the question.
-  let verdict: string;
+  let verdict        ;
   if (findings.length) verdict = 'findings';
   else if (undetermined.length === analyses.length) verdict = 'insufficient-data';
   else if (undetermined.length) verdict = 'no-findings-in-the-analyses-that-could-run';

package/src/runtime/verification/{contract-runner.ts → contract-runner.js}

@@ -46,7 +46,7 @@ const TIMEOUT_EXIT_CODE = 124;
  * @param {*} value
  * @returns {string}
  */
-function truncate(value: any): string {
+function truncate(value     )         {
   if (typeof value !== 'string') return '';
   if (value.length <= MAX_STREAM_CHARS) return value;
   // Keep the TAIL, not the head, and say so.
@@ -77,8 +77,8 @@ const TAP_NOT_OK = /^\s*not ok\b(?:\s+\d+)?(?:\s*-\s*)?(.*)$/gm;
  * @param {string} text
  * @returns {Array<string>} unique identifiers, bounded by MAX_FAILED_TESTS
  */
-function extractFailedTests(text: string): string[] {
-  const seen = new Set<string>();
+function extractFailedTests(text        )           {
+  const seen = new Set        ();
   for (const match of text.matchAll(TAP_NOT_OK)) {
     const name = match[1].trim();
     if (name === '' || /#\s*(?:SKIP|TODO)\b/i.test(name)) continue;
@@ -89,12 +89,12 @@ function extractFailedTests(text: string): string[] {
 }
 
 class VerificationContractRunner {
-  cwd: string;
-  defaultTimeoutMs: number;
-  exec: any;
-  fsImpl: any;
-  logDir: string;
-  logWriteWarned?: boolean;
+  cwd        ;
+  defaultTimeoutMs        ;
+  exec     ;
+  fsImpl     ;
+  logDir        ;
+  logWriteWarned          ;
 
   /**
    * @param {Object|string} [options] a string is accepted for parity with the Python's positional
@@ -103,7 +103,7 @@ class VerificationContractRunner {
    * @param {number} [options.defaultTimeoutMs=60000]
    * @param {Function} [options.exec] injection seam for tests; same contract as `spawnSync`
    */
-  constructor(options: any = {}) {
+  constructor(options      = {}) {
     const opts = typeof options === 'string' ? { cwd: options } : options;
     this.cwd = opts.cwd || process.cwd();
     this.defaultTimeoutMs = opts.defaultTimeoutMs || DEFAULT_TIMEOUT_MS;
@@ -123,7 +123,7 @@ class VerificationContractRunner {
    * @param {string} stderr
    * @returns {string|null} the log path, or null when the log could not be written
    */
-  persistLog(name: string, command: string, stdout: string, stderr: string): string | null {
+  persistLog(name        , command        , stdout        , stderr        )                {
     try {
       this.fsImpl.mkdirSync(this.logDir, { recursive: true });
       const safe = name.replace(/[^A-Za-z0-9._-]+/g, '_');
@@ -132,7 +132,7 @@ class VerificationContractRunner {
         `# check: ${name}\n# command: ${command}\n--- stdout ---\n${stdout || ''}\n--- stderr ---\n${stderr || ''}\n`,
         'utf8');
       return file;
-    } catch (error: any) {
+    } catch (error     ) {
       // An unwritable log directory must not turn a completed check into an error — the check's
       // verdict stands; only the pointer is missing, and its null says so. But a chronic
       // permissions problem should not be invisible either: say so once per runner, on stderr so
@@ -154,7 +154,7 @@ class VerificationContractRunner {
    * @param {string} [stdout]
    * @param {string} [stderr]
    */
-  decorate(result: any, command: string, stdout?: string, stderr?: string): void {
+  decorate(result     , command        , stdout         , stderr         )       {
     const full = `${stdout || ''}\n${stderr || ''}`;
     if (result.status === 'FAIL') {
       const failedTests = extractFailedTests(full);
@@ -162,7 +162,7 @@ class VerificationContractRunner {
     }
     const truncated = (stdout || '').length > MAX_STREAM_CHARS || (stderr || '').length > MAX_STREAM_CHARS;
     if ((result.status === 'FAIL' || truncated) && full.trim() !== '') {
-      result.logPath = this.persistLog(result.name, command, stdout as string, stderr as string);
+      result.logPath = this.persistLog(result.name, command, stdout          , stderr          );
     }
   }
 
@@ -177,7 +177,7 @@ class VerificationContractRunner {
    *   evaluations — a recovery retry must observe live behaviour, so each pass passes a fresh map.
    * @returns {Object} check result
    */
-  runCheck(name: string, command: any, timeoutMs: number = this.defaultTimeoutMs, dedupeCache: Map<string, any> | null = null): any {
+  runCheck(name        , command     , timeoutMs         = this.defaultTimeoutMs, dedupeCache                          = null)      {
     const checkName = name || 'unnamed_check';
 
     // Defect fix (1): the Python defaulted a missing command to `true`, so a typo in a contract
@@ -196,12 +196,12 @@ class VerificationContractRunner {
     if (dedupeCache && dedupeCache.has(dedupeKey)) {
       return { ...dedupeCache.get(dedupeKey), name: checkName, deduplicated: true };
     }
-    const remember = (result: any) => {
+    const remember = (result     ) => {
       if (dedupeCache) dedupeCache.set(dedupeKey, result);
       return result;
     };
 
-    let res: any;
+    let res     ;
     try {
       res = this.exec(command, {
         shell: true,
@@ -214,7 +214,7 @@ class VerificationContractRunner {
         // past anything a check legitimately prints. Only the first 2,000 chars are ever kept.
         maxBuffer: 64 * 1024 * 1024,
       });
-    } catch (error: any) {
+    } catch (error     ) {
       // Mirrors the Python's bare `except Exception` arm: an unspawnable command is a FAIL, not a
       // thrown error that aborts the whole contract.
       return remember({
@@ -263,7 +263,7 @@ class VerificationContractRunner {
     const exitCode = res.status === null || res.status === undefined ? 1 : res.status;
     const passed = res.status === 0;
 
-    const result: any = {
+    const result      = {
       name: checkName,
       command,
       status: passed ? 'PASS' : 'FAIL',
@@ -283,7 +283,7 @@ class VerificationContractRunner {
    * @param {Array<{name?: string, command?: string, timeoutMs?: number}>} checks
    * @returns {{ status: string, checks: Array<Object>, failedChecks: Array<string>, timestamp: string, reason?: string }}
    */
-  evaluateContract(checks: any[]): any {
+  evaluateContract(checks       )      {
     if (!Array.isArray(checks)) {
       throw new Error('evaluateContract expects an array of checks');
     }
@@ -303,10 +303,10 @@ class VerificationContractRunner {
       };
     }
 
-    const results: any[] = [];
-    const failedChecks: string[] = [];
+    const results        = [];
+    const failedChecks           = [];
     let overallStatus = 'PASS';
-    const dedupeCache = new Map<string, any>(); // one evaluation, one cache — a retry pass starts fresh
+    const dedupeCache = new Map             (); // one evaluation, one cache — a retry pass starts fresh
 
     for (const chk of checks) {
       const name = (chk && chk.name) || 'unnamed_check';