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

package/src/state/{run-lock.ts → run-lock.js}

@@ -25,40 +25,40 @@ const LOCK_FILE = 'run.lock';
 const CLAIM_PREFIX = `${LOCK_FILE}.claim.`;
 const TEMP_NAME = /^\.run\.lock\.([0-9a-f]{32})\.tmp$/;
 
-function loadVersion(): string {
+function loadVersion()         {
   try { return require('../../package.json').version; } catch { return '0.0.0-installed'; }
 }
 const DOFLOW_VERSION = loadVersion();
 
 /** Holds of this process, by resolved scope root: a nested acquisition counts instead of waiting on itself. */
-const held = new Map<string, { count: number, handle: any }>();
+const held = new Map                                        ();
 
-function runLockPath(scopeRoot: string): string { return path.join(path.resolve(scopeRoot), '.doflow', 'state', LOCK_FILE); }
+function runLockPath(scopeRoot        )         { return path.join(path.resolve(scopeRoot), '.doflow', 'state', LOCK_FILE); }
 
-function atomicsSleep(ms: number): void {
+function atomicsSleep(ms        )       {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
 /** Alive when signal 0 reaches it, or it exists but belongs to someone else (EPERM). */
-function defaultIsAlive(pid: any): boolean {
+function defaultIsAlive(pid     )          {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0);
     return true;
-  } catch (err: any) {
+  } catch (err     ) {
     return err.code === 'EPERM';
   }
 }
 
-function scopeLabel({ scope, scopeRoot }: { scope: string, scopeRoot: string }): string {
+function scopeLabel({ scope, scopeRoot }                                      )         {
   return scope === 'global' ? `global scope (${scopeRoot})` : `project ${scopeRoot}`;
 }
 
-function holderLabel(holder: any): string {
+function holderLabel(holder     )         {
   return holder ? `pid ${holder.pid}, ${holder.command}, started ${holder.startedAt}` : 'holder unknown';
 }
 
-const STALE_REASONS: Record<string, string> = Object.freeze({ 'not-running': 'that process is not running', expired: 'it is older than 10 minutes' });
+const STALE_REASONS                         = Object.freeze({ 'not-running': 'that process is not running', expired: 'it is older than 10 minutes' });
 
 /**
  * The one text of every run-lock line, so the CLI prints exactly these.
@@ -66,7 +66,7 @@ const STALE_REASONS: Record<string, string> = Object.freeze({ 'not-running': 'th
  * @param {{scope: string, scopeRoot: string, holder?: Object|null, waitMs?: number, reason?: string,
  *   lockPath?: string, waitedMs?: number, code?: string}} details
  */
-function formatRunLockMessage(kind: string, details: any): string {
+function formatRunLockMessage(kind        , details     )         {
   const where = scopeLabel(details);
   switch (kind) {
     case 'waiting':
@@ -85,7 +85,7 @@ function formatRunLockMessage(kind: string, details: any): string {
 }
 
 class RunLockError extends Error {
-  constructor(details: any) {
+  constructor(details     ) {
     super(formatRunLockMessage('error', details));
     this.name = 'RunLockError';
     Object.assign(this, { code: details.code, lockPath: details.lockPath, scopeRoot: details.scopeRoot });
@@ -93,7 +93,7 @@ class RunLockError extends Error {
 }
 
 class RunLockTimeoutError extends Error {
-  constructor(details: any) {
+  constructor(details     ) {
     super(formatRunLockMessage('timeout', details));
     this.name = 'RunLockTimeoutError';
     Object.assign(this, { holder: details.holder, lockPath: details.lockPath, scopeRoot: details.scopeRoot, waitedMs: details.waitedMs });
@@ -101,14 +101,14 @@ class RunLockTimeoutError extends Error {
 }
 
 class RunLockLostError extends Error {
-  constructor(details: any) {
+  constructor(details     ) {
     super(formatRunLockMessage('lost', details));
     this.name = 'RunLockLostError';
     Object.assign(this, { lockPath: details.lockPath, scopeRoot: details.scopeRoot });
   }
 }
 
-function isIdentified(record: any): boolean {
+function isIdentified(record     )          {
   return Boolean(record) && typeof record.token === 'string' && Number.isInteger(record.pid) && typeof record.hostname === 'string';
 }
 
@@ -117,15 +117,15 @@ function isIdentified(record: any): boolean {
  * replaced between the two calls can never pair one instance's record with another's age.
  * @returns {{record: Object|null, stat: fs.Stats, key: string}|null} null when there is no lock
  */
-function readLockFile(fsImpl: any, lockPath: string): { record: any, stat: any, key: string } | null {
-  let fd: any;
+function readLockFile(fsImpl     , lockPath        )                                                 {
+  let fd     ;
   try {
     fd = fsImpl.openSync(lockPath, 'r');
-  } catch (err: any) {
+  } catch (err     ) {
     if (err.code !== 'ENOENT') throw err;
     // A dangling symlink opens as ENOENT yet blocks link(); judge it by its own lstat.
     let stat;
-    try { stat = fsImpl.lstatSync(lockPath); } catch (lstatErr: any) {
+    try { stat = fsImpl.lstatSync(lockPath); } catch (lstatErr     ) {
       if (lstatErr.code === 'ENOENT') return null;
       throw lstatErr;
     }
@@ -142,12 +142,12 @@ function readLockFile(fsImpl: any, lockPath: string): { record: any, stat: any,
   }
 }
 
-function instanceKey(record: any, stat: any): string {
+function instanceKey(record     , stat     )         {
   return record ? record.token : `u-${stat.dev}-${stat.ino}-${Math.floor(stat.mtimeMs)}`;
 }
 
 /** @returns {null|'not-running'|'expired'} */
-function staleReason(found: any, { token, hostname, isAlive, now, staleMs }: any): 'not-running' | 'expired' | null {
+function staleReason(found     , { token, hostname, isAlive, now, staleMs }     )                                   {
   const { record, stat } = found;
   if (record && record.token === token) return null;
   if (record && record.hostname === hostname && (record.pid === process.pid || !isAlive(record.pid))) return 'not-running';
@@ -155,16 +155,16 @@ function staleReason(found: any, { token, hostname, isAlive, now, staleMs }: any
   return null;
 }
 
-function unlinkQuietly(fsImpl: any, file: string): void {
+function unlinkQuietly(fsImpl     , file        )       {
   try { fsImpl.unlinkSync(file); } catch { /* already gone, or the stale rule clears it later */ }
 }
 
-function readRaw(fsImpl: any, file: string): string | null {
+function readRaw(fsImpl     , file        )                {
   try { return fsImpl.readFileSync(file, 'utf8'); } catch { return null; }
 }
 
 /** A claim left by a run that died while clearing: its process is gone, or it is older than claimStaleMs. */
-function isOrphanClaim(fsImpl: any, claimPath: string, { hostname, isAlive, now, claimStaleMs }: any): boolean {
+function isOrphanClaim(fsImpl     , claimPath        , { hostname, isAlive, now, claimStaleMs }     )          {
   let stat;
   try { stat = fsImpl.statSync(claimPath); } catch { return false; }
   if (now() - stat.mtimeMs > claimStaleMs) return true;
@@ -174,12 +174,12 @@ function isOrphanClaim(fsImpl: any, claimPath: string, { hostname, isAlive, now,
 }
 
 /** Creates the claim for one lock instance. @returns {boolean} true when this run now holds it */
-function createClaim(fsImpl: any, claimPath: string, { token, hostname, target }: any): boolean {
+function createClaim(fsImpl     , claimPath        , { token, hostname, target }     )          {
   const body = `${JSON.stringify({ version: RECORD_VERSION, token, pid: process.pid, hostname, at: new Date().toISOString(), target })}\n`;
   try {
     fsImpl.writeFileSync(claimPath, body, { flag: 'wx' });
     return true;
-  } catch (err: any) {
+  } catch (err     ) {
     if (err.code === 'EEXIST') return false;
     throw err;
   }
@@ -191,7 +191,7 @@ function createClaim(fsImpl: any, claimPath: string, { token, hostname, target }
  * back when what was moved is not what was judged, so a fresh claim is never deleted by mistake.
  * @returns {boolean}
  */
-function claimInstance(fsImpl: any, stateDir: string, key: string, options: any): boolean {
+function claimInstance(fsImpl     , stateDir        , key        , options     )          {
   const claimPath = path.join(stateDir, `${CLAIM_PREFIX}${key}`);
   for (let attempt = 0; attempt < 2; attempt += 1) {
     if (createClaim(fsImpl, claimPath, { token: options.token, hostname: options.hostname, target: key })) return true;
@@ -213,7 +213,7 @@ function claimInstance(fsImpl: any, stateDir: string, key: string, options: any)
  * Removes the stale instance `found` under its claim.
  * @returns {'cleared'|'aborted'}
  */
-function takeOver(fsImpl: any, stateDir: string, lockPath: string, found: any, options: any): 'cleared' | 'aborted' {
+function takeOver(fsImpl     , stateDir        , lockPath        , found     , options     )                        {
   if (!claimInstance(fsImpl, stateDir, found.key, options)) return 'aborted';
   const claimPath = path.join(stateDir, `${CLAIM_PREFIX}${found.key}`);
   try {
@@ -222,7 +222,7 @@ function takeOver(fsImpl: any, stateDir: string, lockPath: string, found: any, o
     // Judged again under the claim: a holder whose checkpoint renewed the lock since the first
     // judgment is no longer stale, and its lock stays.
     if (!staleReason(current, options)) return 'aborted';
-    try { fsImpl.unlinkSync(lockPath); } catch (err: any) {
+    try { fsImpl.unlinkSync(lockPath); } catch (err     ) {
       if (err.code !== 'ENOENT') return 'aborted';
     }
     return 'cleared';
@@ -235,7 +235,7 @@ function takeOver(fsImpl: any, stateDir: string, lockPath: string, found: any, o
 
 /** Removes owner temp files left by runs that died while they waited, judged by the stale rule as
  * a lock would be: interrupting a waiting run is the one exit that never reaches its own cleanup. */
-function sweepOrphanTemps(fsImpl: any, stateDir: string, judge: any): void {
+function sweepOrphanTemps(fsImpl     , stateDir        , judge     )       {
   let names;
   try { names = fsImpl.readdirSync(stateDir); } catch { return; }
   for (const name of names) {
@@ -249,7 +249,7 @@ function sweepOrphanTemps(fsImpl: any, stateDir: string, judge: any): void {
 }
 
 /** Removes, innermost first, the directories an acquisition created, stopping at the first non-empty one. */
-function removeCreatedDirs(fsImpl: any, stateDir: string, firstCreated: any): void {
+function removeCreatedDirs(fsImpl     , stateDir        , firstCreated     )       {
   if (!firstCreated) return;
   const top = path.resolve(firstCreated);
   for (let dir = stateDir; ; dir = path.dirname(dir)) {
@@ -267,11 +267,11 @@ function removeCreatedDirs(fsImpl: any, stateDir: string, firstCreated: any): vo
  *   checkpoint: () => void, release: () => void}}
  * @throws {RunLockTimeoutError|RunLockError}
  */
-function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scope: 'global' | 'project', command: string }, {
+function acquireRunLock({ scopeRoot, scope, command }                                                                     , {
   waitMs = 60_000, pollMs = 250, staleMs = 600_000, claimStaleMs = 30_000,
   now = Date.now, isAlive = defaultIsAlive, hostname = os.hostname(),
-  log = (line: string) => process.stderr.write(`${line}\n`), fsImpl = fs, sleep = atomicsSleep,
-}: any = {}): any {
+  log = (line        ) => process.stderr.write(`${line}\n`), fsImpl = fs, sleep = atomicsSleep,
+}      = {})      {
   const root = path.resolve(scopeRoot);
   const existing = held.get(root);
   if (existing) {
@@ -283,7 +283,7 @@ function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scop
   const stateDir = path.dirname(lockPath);
   const token = crypto.randomBytes(16).toString('hex');
   const where = { scope, scopeRoot: root, lockPath };
-  const fail = (code: any) => new RunLockError({ ...where, code });
+  const fail = (code     ) => new RunLockError({ ...where, code });
 
   const tempPath = path.join(stateDir, `.${LOCK_FILE}.${token}.tmp`);
   const record = {
@@ -292,20 +292,20 @@ function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scop
   };
   // A first-ever run that gives up removes the state directory it created. Doing so between this
   // run's mkdir and its temp write surfaces here as ENOENT, so both steps are tried once more.
-  let firstCreated: any;
+  let firstCreated     ;
   for (let attempt = 0; ; attempt += 1) {
-    try { firstCreated = fsImpl.mkdirSync(stateDir, { recursive: true }); } catch (err: any) { throw fail(err.code); }
+    try { firstCreated = fsImpl.mkdirSync(stateDir, { recursive: true }); } catch (err     ) { throw fail(err.code); }
     try {
       fsImpl.writeFileSync(tempPath, `${JSON.stringify(record)}\n`, { flag: 'wx' });
       break;
-    } catch (err: any) {
+    } catch (err     ) {
       if (err.code === 'ENOENT' && attempt === 0) continue;
       unlinkQuietly(fsImpl, tempPath);
       removeCreatedDirs(fsImpl, stateDir, firstCreated);
       throw fail(err.code);
     }
   }
-  const giveUp = (error: any) => {
+  const giveUp = (error     ) => {
     unlinkQuietly(fsImpl, tempPath);
     removeCreatedDirs(fsImpl, stateDir, firstCreated);
     return error;
@@ -314,16 +314,16 @@ function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scop
   const judge = { token, hostname, isAlive, now, staleMs, claimStaleMs };
   sweepOrphanTemps(fsImpl, stateDir, judge);
   const start = now();
-  const cleared: any[] = [];
-  let lastHolder: any = null;
+  const cleared        = [];
+  let lastHolder      = null;
   let announced = false;
   while (now() - start < waitMs) {
     try {
       fsImpl.linkSync(tempPath, lockPath);
-    } catch (err: any) {
+    } catch (err     ) {
       if (err.code !== 'EEXIST') throw giveUp(fail(err.code));
       let found;
-      try { found = readLockFile(fsImpl, lockPath); } catch (readErr: any) { throw giveUp(fail(readErr.code)); }
+      try { found = readLockFile(fsImpl, lockPath); } catch (readErr     ) { throw giveUp(fail(readErr.code)); }
       if (!found) continue;
       lastHolder = found.record;
       const reason = staleReason(found, judge);
@@ -346,8 +346,8 @@ function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scop
   throw giveUp(new RunLockTimeoutError({ ...where, holder: lastHolder, waitedMs: now() - start }));
 }
 
-function holdHandle({ fsImpl, root, stateDir, lockPath, token, hostname, firstCreated, where, now, waitedMs, cleared }: any): any {
-  const entry: { count: number, handle: any } = { count: 1, handle: null };
+function holdHandle({ fsImpl, root, stateDir, lockPath, token, hostname, firstCreated, where, now, waitedMs, cleared }     )      {
+  const entry                                 = { count: 1, handle: null };
   let released = false;
 
   const releaseNow = () => {

package/core/.antigravity-plugin/hooks.json

@@ -1,39 +0,0 @@
-{
-  "description": "DoFlow lifecycle hooks for Google Antigravity (IDE & CLI). Uses stdin/stdout JSON protocol for real-time gating.",
-  "hooks": {
-    "SessionStart": [
-      {
-        "type": "command",
-        "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/session-start.sh\""
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "^(run_command|replace_file_content|write_to_file|multi_replace_file_content)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$DOFLOW_PROJECT_DIR/.doflow/scripts/stream-hook-runner.js\""
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "^(replace_file_content|write_to_file|multi_replace_file_content)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/post-edit-lint.sh\""
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "type": "command",
-        "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/stop-check.sh\""
-      }
-    ]
-  }
-}

package/core/harnesses/shared/hooks/adapters/arg-fields.js

@@ -1,19 +0,0 @@
-'use strict';
-
-/**
- * Shared toolCall.args field-name lookup for the toolCall/args envelope adapters
- * (antigravity.js, gemini.js's fallback path) both read when mapping to canonical
- * file_path/command. Extracted because both adapters carried an identical copy.
- */
-
-const FILE_PATH_ARG_FIELDS = ['AbsolutePath', 'TargetFile', 'Path', 'file_path', 'path'];
-const COMMAND_ARG_FIELDS = ['CommandLine', 'command'];
-
-function firstArgField(args, fields) {
-  for (const field of fields) {
-    if (args && args[field]) return args[field];
-  }
-  return '';
-}
-
-module.exports = { FILE_PATH_ARG_FIELDS, COMMAND_ARG_FIELDS, firstArgField };

package/core/harnesses/shared/hooks/adapters/gemini.js

@@ -1,114 +0,0 @@
-'use strict';
-
-/**
- * Gemini CLI payload/decision adapter for the Cross-Harness Hook Runner (design.md C2's
- * Payload Adapter / Decision Adapter seam, D2).
- *
- * Gemini's own native contract — evidenced by core/harnesses/gemini/hooks/*.sh and
- * core/harnesses/gemini/hooks/hooks.json, all currently invoked directly by bash rather than
- * through this runner — already speaks field names close to Claude/Codex/Kiro's, NOT
- * Antigravity's toolCall/args envelope:
- *
- *   SessionStart           : stdin  { session_id, cwd }                          (session-start.sh)
- *   BeforeTool (~PreToolUse): stdin  { tool_name, tool_input: { file_path, command } }
- *                             stdout { decision: "allow"|"deny", reason } — TOP-LEVEL, not
- *                             nested under hookSpecificOutput.permissionDecision like
- *                             Claude/Codex (confirmed in gemini/hooks/pre-bash-guard.sh's header).
- *   AfterTool (~PostToolUse): stdin { tool_name, tool_input: { file_path }, session_id }
- *                             (post-edit-lint.sh) — stdout {} (ack; no Phase A policy owns this
- *                             event, post-edit-lint.sh's collector role is out of FR-001's scope)
- *   Stop                    : NOT a documented Gemini lifecycle event — gemini/hooks/
- *                             post-edit-lint.sh's own comment states "Gemini has no
- *                             Stop-equivalent event," and no stop-check.sh ships under
- *                             gemini/hooks/ today. Handled defensively below (same field-name
- *                             union stop-check.sh itself accepts) in case a future Gemini
- *                             version adds one, or in case core/harnesses/shared/hooks/hooks.json's
- *                             existing (currently dangling) Stop entry is corrected to a real target.
- *
- * NFR-002 note: core/harnesses/shared/hooks/hooks.json has historically routed PreToolUse through
- * this runner using Antigravity's { toolCall: { name, args } } envelope — inherited from this
- * runner's original Antigravity-only design (see the runner's own prior header comment), not
- * verified against Gemini's own documented schema above. toCanonical() below reads the
- * tool_name/tool_input shape first (Gemini's own evidenced contract) and falls back to the
- * toolCall envelope only if that shape isn't present, so this adapter is correct once that
- * wiring is corrected without silently breaking before it is.
- */
-
-const { FILE_PATH_ARG_FIELDS, COMMAND_ARG_FIELDS, firstArgField } = require('./arg-fields');
-
-function toCanonical(event, payload) {
-  const safePayload = payload && typeof payload === 'object' ? payload : {};
-
-  switch (event) {
-    case 'SessionStart':
-      return { session_id: safePayload.session_id || '', cwd: safePayload.cwd || '' };
-
-    case 'PreToolUse': {
-      if (safePayload.tool_name !== undefined || safePayload.tool_input !== undefined) {
-        const toolInput = safePayload.tool_input || {};
-        return {
-          tool_name: safePayload.tool_name || '',
-          tool_input: {
-            file_path: toolInput.file_path || '',
-            command: toolInput.command || '',
-          },
-        };
-      }
-      // Defensive fallback: Antigravity-shaped envelope (see header note).
-      const toolCall = safePayload.toolCall || {};
-      const args = toolCall.args || {};
-      return {
-        tool_name: toolCall.name || '',
-        tool_input: {
-          file_path: firstArgField(args, FILE_PATH_ARG_FIELDS),
-          command: firstArgField(args, COMMAND_ARG_FIELDS),
-        },
-      };
-    }
-
-    case 'PostToolUse':
-      return {
-        tool_name: safePayload.tool_name || '',
-        session_id: safePayload.session_id || '',
-        tool_input: { file_path: (safePayload.tool_input && safePayload.tool_input.file_path) || '' },
-      };
-
-    case 'Stop':
-      return {
-        session_id: safePayload.session_id || '',
-        transcript_path: safePayload.transcript_path || safePayload.transcriptPath || '',
-      };
-
-    default:
-      return safePayload;
-  }
-}
-
-function toNative(event, decision) {
-  const safeDecision = decision || { decision: 'allow' };
-
-  switch (event) {
-    case 'PreToolUse':
-      if (safeDecision.decision === 'deny') {
-        return { decision: 'deny', reason: safeDecision.reason };
-      }
-      return { decision: 'allow' };
-
-    case 'PostToolUse':
-      return {};
-
-    case 'Stop':
-      if (safeDecision.decision === 'deny') {
-        return { decision: 'deny', reason: safeDecision.reason };
-      }
-      return { decision: 'allow' };
-
-    case 'SessionStart':
-      return {};
-
-    default:
-      return { decision: 'allow' };
-  }
-}
-
-module.exports = { toCanonical, toNative };

package/core/harnesses/shared/hooks/hooks.json

@@ -1,47 +0,0 @@
-{
-  "description": "DoFlow shared lifecycle hooks schema for Antigravity, Gemini, and Claude.",
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/session-start.sh\""
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "^(run_command|run_shell_command|replace_file_content|write_to_file|multi_replace_file_content|edit_file|Edit|Write)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$DOFLOW_PROJECT_DIR/.doflow/scripts/stream-hook-runner.js\""
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "^(replace_file_content|write_to_file|multi_replace_file_content|edit_file|Edit|Write)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/post-edit-lint.sh\""
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$DOFLOW_PROJECT_DIR/.gemini/hooks/stop-check.sh\""
-          }
-        ]
-      }
-    ]
-  }
-}