@rmyndharis/aimhooman 0.1.0 → 0.1.2

package/bin/aimhooman.mjs

@@ -3,24 +3,24 @@ import { execFileSync } from 'node:child_process';
 import { chmodSync, lstatSync, readFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { GIT_TIMEOUT_MS } from '../src/git-environment.mjs';
 import { newEngineWithDiagnostics } from '../src/scan.mjs';
 import { exitCode, human, jsonReport, visible } from '../src/report.mjs';
 import {
     GitRevisionError,
     gitConfig,
-    hasStagedChanges,
     introducedCommits,
     openRepo,
     readCommitPath,
     readStagedPath,
+    stagedPaths,
     stagedRenameSources,
     unstagePaths,
     withIndexFromTree,
 } from '../src/gitx.mjs';
 import { loadConfig, loadOverrides, loadProjectPolicy, normalizeOverrideTarget, saveConfig, saveOverrides } from '../src/state.mjs';
 import { applyExclude, inspectExclude, patternsForRules, removeExclude } from '../src/exclude.mjs';
-import { hookDiagnostics, installHooks, installGlobalHooks, uninstallGlobalHooks, globalHooksDir, installedHooks, uninstallHooks, unrestoredChainedBackups } from '../src/githooks.mjs';
-import { runHook } from '../src/hook.mjs';
+import { hookDiagnostics, installHooks, installGlobalHooks, uninstallGlobalHooks, globalHooksDir, installedHooks, remainingDispatchers, uninstallHooks, unrestoredChainedBackups } from '../src/githooks.mjs';
 import { ArgumentError, parseArguments } from '../src/args.mjs';
 import { engineForPolicy, scanGitTarget, scanMessage } from '../src/scan-target.mjs';
 import { resolvePolicy } from '../src/policy-resolver.mjs';
@@ -38,8 +38,7 @@ const LIFECYCLE_LOCK_OPTIONS = { retries: 1000 };
 function tryRepo() {
     try {
         return openRepo();
-    } catch (error) {
-        if (error?.name === 'StateMigrationError') throw error;
+    } catch {
         return null;
     }
 }
@@ -49,6 +48,7 @@ function currentRepositoryIsBare() {
         return execFileSync('git', ['rev-parse', '--is-bare-repository'], {
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: GIT_TIMEOUT_MS,
         }).trim() === 'true';
     } catch {
         return false;
@@ -160,10 +160,17 @@ function emitDiagnostics(diagnostics = []) {
 }
 
 function incompleteMessage(scan) {
-    const skipped = Object.entries(scan.stats?.skipped || {})
+    const reasons = scan.stats?.skipped || {};
+    const skipped = Object.entries(reasons)
         .map(([reason, count]) => `${reason}=${count}`)
         .join(', ');
-    return `aimhooman: scan incomplete${skipped ? ` (${skipped})` : ''}; reduce the target or limits and retry\n`;
+    // Every other reason is a size or budget the caller can shrink. A pack that
+    // will not compile is not, and the warning above already names the file and
+    // the error, so point at that instead of misdirecting to the limits.
+    const hint = reasons['local-pack-error']
+        ? 'fix the reported rule pack and retry'
+        : 'reduce the target or limits and retry';
+    return `aimhooman: scan incomplete${skipped ? ` (${skipped})` : ''}; ${hint}\n`;
 }
 
 function snapshotFile(path) {
@@ -194,6 +201,7 @@ function gitConfigAtScope(root, scope, key) {
             cwd: root,
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: GIT_TIMEOUT_MS,
         }).trim();
     } catch {
         return '';
@@ -201,7 +209,7 @@ function gitConfigAtScope(root, scope, key) {
 }
 
 function gitVersion() {
-    try { return execFileSync('git', ['--version'], { encoding: 'utf8' }).trim(); }
+    try { return execFileSync('git', ['--version'], { encoding: 'utf8', timeout: GIT_TIMEOUT_MS }).trim(); }
     catch { return 'Git unavailable'; }
 }
 
@@ -284,9 +292,41 @@ function cmdPrecommit(args) {
             }
         }
         for (const source of stagedRenameSources(repo, paths)) unstageTargets.add(source);
+        // The empty-commit hint is derived from the staged paths captured before
+        // repair, not from a second git read after `git restore --staged`. That
+        // post-repair read followed an index write and could transiently report
+        // the wrong state under heavy CI load, flaking the repair tests.
+        // unstagePaths is atomic (it throws on failure), so when every staged
+        // path is a repair target the index matches HEAD afterward. The capture
+        // is best-effort and runs before the repair: if this read fails the
+        // unstage still runs and the hint is omitted (empty stays false) rather
+        // than skipping the repair or blocking the commit.
+        let stagedBefore;
+        try {
+            stagedBefore = stagedPaths(repo);
+        } catch {
+            stagedBefore = null;
+        }
         unstagePaths(repo, [...unstageTargets]);
-        let empty = false;
-        try { empty = !hasStagedChanges(repo); } catch { /* could not re-read */ }
+        // Under heavy CI load a `git restore --staged` or the rename-source
+        // detection above can transiently leave a target staged, which flakes
+        // the repair tests and would let an artifact ride through. Re-detect
+        // rename sources and re-unstage any still-staged target until every
+        // target is gone or the budget is reached.
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            let stillStaged;
+            try {
+                for (const source of stagedRenameSources(repo, paths)) unstageTargets.add(source);
+                stillStaged = new Set(stagedPaths(repo));
+            } catch {
+                break;
+            }
+            const pending = [...unstageTargets].filter((path) => stillStaged.has(path));
+            if (!pending.length) break;
+            unstagePaths(repo, pending);
+        }
+        const empty = stagedBefore !== null
+            && stagedBefore.every((path) => unstageTargets.has(path));
         process.stderr.write(
             `aimhooman: unstaged ${paths.length} AI artifact(s) from this commit: ${paths.map(visible).join(', ')}${empty ? ' (nothing else staged — the commit will be empty)' : ''}\n`
         );
@@ -456,7 +496,7 @@ function cmdRefcheck(args) {
             return 30;
         }
         if (/^0+$/.test(newObjectId)) continue;
-        updates.push({ oldObjectId, newObjectId });
+        updates.push({ oldObjectId, newObjectId, ref });
     }
 
     let commits;
@@ -619,7 +659,7 @@ function cmdInit(args) {
         const aimDir = globalHooksDir();
         let existing = '';
         try {
-            existing = execFileSync('git', ['config', '--global', '--get', 'core.hooksPath'], { encoding: 'utf8' }).trim();
+            existing = execFileSync('git', ['config', '--global', '--get', 'core.hooksPath'], { encoding: 'utf8', timeout: GIT_TIMEOUT_MS }).trim();
         } catch { /* unset */ }
         if (existing && existing !== aimDir) {
             console.error(
@@ -632,7 +672,7 @@ function cmdInit(args) {
         // could silently disable a system-wide hook manager, so refuse here too.
         let systemHooksPath = '';
         try {
-            systemHooksPath = execFileSync('git', ['config', '--system', '--get', 'core.hooksPath'], { encoding: 'utf8' }).trim();
+            systemHooksPath = execFileSync('git', ['config', '--system', '--get', 'core.hooksPath'], { encoding: 'utf8', timeout: GIT_TIMEOUT_MS }).trim();
         } catch { /* unset or no system config */ }
         if (systemHooksPath) {
             console.error(
@@ -656,7 +696,7 @@ function cmdInit(args) {
                 console.error('aimhooman: global hook installation aborted; core.hooksPath was not changed');
                 return 20;
             }
-            execFileSync('git', ['config', '--global', 'core.hooksPath', rep.dir]);
+            execFileSync('git', ['config', '--global', 'core.hooksPath', rep.dir], { timeout: GIT_TIMEOUT_MS });
         } catch (error) {
             const rollbackFailures = [];
             for (const snapshot of hookSnapshots.reverse()) {
@@ -666,8 +706,8 @@ function cmdInit(args) {
                 }
             }
             try {
-                if (existing) execFileSync('git', ['config', '--global', 'core.hooksPath', existing]);
-                else execFileSync('git', ['config', '--global', '--unset', 'core.hooksPath'], { stdio: 'ignore' });
+                if (existing) execFileSync('git', ['config', '--global', 'core.hooksPath', existing], { timeout: GIT_TIMEOUT_MS });
+                else execFileSync('git', ['config', '--global', '--unset', 'core.hooksPath'], { stdio: 'ignore', timeout: GIT_TIMEOUT_MS });
             } catch (rollbackError) {
                 rollbackFailures.push(`global core.hooksPath: ${rollbackError.message}`);
             }
@@ -728,7 +768,13 @@ function cmdInit(args) {
         rep = installHooks(repo, CLI_PATH);
         const activeHooks = installedHooks(repo);
         if (!REQUIRED_GIT_HOOKS.every((name) => activeHooks.includes(name))) {
-            throw new Error('hook installation incomplete; repository guard is not active');
+            // installHooks declines rather than throws when the hooks directory is
+            // not ours, and its warnings are the only record of why. They are
+            // printed on the success path only, so carry them into the failure or
+            // the user is told nothing but "incomplete". The prefix is load-bearing:
+            // the exit-code branch below matches on it.
+            const cause = rep.shared && rep.warnings.length ? `${rep.warnings.join('; ')}; ` : '';
+            throw new Error(`hook installation incomplete; ${cause}repository guard is not active`);
         }
         saveConfig(repo.stateDir, { profile });
         applyExclude(repo.excludeFile, patternsForRules(eng.rules));
@@ -816,7 +862,6 @@ function cmdStatus(args) {
     console.log(`overrides: ${overrides.allow.length} allow, ${overrides.deny.length} deny`);
     console.log(`excludes: ${excludeError ? `unknown (malformed markers: ${excludeError}; run: aimhooman init)` : excludes.current ? 'current' : excludes.installed ? 'out of date (run: aimhooman init)' : 'not installed (run: aimhooman init)'}`);
     for (const error of errors) console.log(`warning:  ${error.message}`);
-    for (const diagnostic of repo.stateDiagnostics || []) console.log(`${diagnostic.level || 'info'}: ${diagnostic.message}`);
     const localHooks = gitConfigAtScope(repo.root, '--local', 'core.hooksPath');
     const globalHooks = gitConfigAtScope(repo.root, '--global', 'core.hooksPath');
     console.log(`hooks path: local=${localHooks || 'unset'}, global=${globalHooks || 'unset'}`);
@@ -885,6 +930,19 @@ function cmdOverride(args, allow) {
             `secret rules cannot be allowed at --scope rule (that would suppress every matching secret path under every profile); use --scope secret-path <path> to allow a specific secret path`,
         );
     }
+    // A path that matches a secret rule cannot be silenced by a path (or rule)
+    // allow: only --scope secret-path suppresses secret findings, deliberately,
+    // so a local override cannot hide a possible leaked key. Without this check
+    // a bare `allow .env.minimal` would report success but leave the block in
+    // place, which reads as a broken allow.
+    if (allow && scope !== 'secret-path'
+        && engine.checkPaths([target]).some((finding) => finding.category === 'secret')) {
+        throw new ArgumentError(
+            `"${target}" matches a secret rule, so a ${scope} allow cannot silence it `
+            + '(a local override must not hide a possible leaked key); '
+            + 'use --scope secret-path to explicitly allow this specific path',
+        );
+    }
     if (scope === 'secret-path' && !allow) {
         throw new ArgumentError('--scope secret-path is only valid with allow');
     }
@@ -1370,10 +1428,6 @@ function cmdDoctor(args) {
     } else {
         console.log(`ok host adapters present (${adapters.present}/${adapters.total})`);
     }
-    for (const diagnostic of repo.stateDiagnostics || []) {
-        console.log(`${diagnostic.level === 'error' ? 'x' : '!'} state: ${diagnostic.message}`);
-        if (diagnostic.level === 'error') ok = false;
-    }
     const gitRuntime = supportedGitVersion();
     if (gitRuntime.supported) {
         console.log(`ok runtime Node ${process.versions.node}; ${gitRuntime.display}`);
@@ -1441,7 +1495,7 @@ function cmdUninstall(args) {
         const aimDir = globalHooksDir();
         const readGlobalHooksPath = () => {
             try {
-                return execFileSync('git', ['config', '--global', '--get', 'core.hooksPath'], { encoding: 'utf8' }).trim();
+                return execFileSync('git', ['config', '--global', '--get', 'core.hooksPath'], { encoding: 'utf8', timeout: GIT_TIMEOUT_MS }).trim();
             } catch { return ''; }
         };
         const current = readGlobalHooksPath();
@@ -1449,7 +1503,7 @@ function cmdUninstall(args) {
         if (current === aimDir) {
             unsetAttempted = true;
             try {
-                execFileSync('git', ['config', '--global', '--unset', 'core.hooksPath'], { stdio: ['ignore', 'ignore', 'ignore'] });
+                execFileSync('git', ['config', '--global', '--unset', 'core.hooksPath'], { stdio: ['ignore', 'ignore', 'ignore'], timeout: GIT_TIMEOUT_MS });
             } catch { /* may have failed; re-verify below */ }
             // A read-only or locked ~/.gitconfig can make --unset fail silently.
             // Do not remove the dispatchers while core.hooksPath still resolves to
@@ -1484,11 +1538,20 @@ function cmdUninstall(args) {
     return withLock(join(repo.commonDir, 'aimhooman-lifecycle.lock'), () => {
     const rep = uninstallHooks(repo);
     removeExclude(repo.excludeFile);
-    console.log('aimhooman: uninstalled');
+    // Trust the directory, not the report. Every refusal below leaves a working
+    // dispatcher behind, and one printed under "uninstalled" reads as done.
+    const remaining = remainingDispatchers(repo);
+    if (remaining.length) {
+        console.error('aimhooman: NOT uninstalled; leaving dispatchers in place:');
+        for (const path of remaining) console.error(`  ${path}`);
+        console.error('  These still guard every commit. Remove them by hand to finish uninstalling.');
+    } else {
+        console.log('aimhooman: uninstalled');
+    }
     if (rep.removed.length) console.log(`  hooks removed:  ${rep.removed.join(', ')}`);
     if (rep.restored.length) console.log(`  hooks restored: ${rep.restored.join(', ')}`);
     for (const w of rep.warnings || []) console.log(`  warning: ${w}`);
-    for (const f of rep.failures || []) console.log(`  warning: ${f}`);
+    for (const f of rep.failures || []) console.error(`  failure: ${f}`);
     const unrestored = purge ? unrestoredChainedBackups(repo) : [];
     if (purge) {
         // Never wipe stateDir while a predecessor hook backup is still on disk:
@@ -1516,6 +1579,7 @@ function cmdUninstall(args) {
     try {
         globalHooksPath = execFileSync('git', ['config', '--global', '--get', 'core.hooksPath'], {
             encoding: 'utf8',
+            timeout: GIT_TIMEOUT_MS,
         }).trim();
     } catch { /* unset */ }
     if (globalHooksPath === aimDir) {
@@ -1523,7 +1587,7 @@ function cmdUninstall(args) {
         console.log('  eligible non-bare repositories that inherit core.hooksPath are still guarded.');
         console.log('  run `aimhooman uninstall --global` to remove it.');
     }
-    return rep.failures?.length || unrestored.length ? 30 : 0;
+    return remaining.length || rep.failures?.length || unrestored.length ? 30 : 0;
     }, LIFECYCLE_LOCK_OPTIONS);
 }
 
@@ -1563,7 +1627,14 @@ if (argv[0] === 'hook') {
         console.error('aimhooman: hook requires exactly one supported event');
         process.exit(20);
     }
-    runHook(hookArgs)
+    // hook.mjs (the PreToolUse shell parser) is by far the largest module and is
+    // only needed for the `hook` subcommand. Loading it lazily cuts the heaviest
+    // parse cost from every other command's startup, so the lifecycle-lock
+    // candidate is published earlier. This widens the margin under the queue-wait
+    // budget rather than guaranteeing it: openRepo's git spawns still set the
+    // floor on slow runners.
+    import('../src/hook.mjs')
+        .then(({ runHook }) => runHook(hookArgs))
         .then((code) => {
             // Drain the permission decision before exiting: on a piped stdout,
             // process.exit() can cut off the emit() write and drop a deny. The

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rmyndharis/aimhooman",
-    "version": "0.1.0",
+    "version": "0.1.2",
     "description": "AI works. Hoomans ship. Keep AI session files, secrets, and attribution out of your commits.",
     "homepage": "https://github.com/rmyndharis/aimhooman#readme",
     "repository": {

package/rules/attribution.json

@@ -1,14 +1,14 @@
 [
     {
         "id": "attribution.claude-coauthor",
-        "version": 1,
+        "version": 2,
         "provider": "claude-code",
         "category": "ai-attribution",
         "confidence": "high",
         "kind": "message",
         "match": {
             "content": [
-                "(?i)^\\s*co-authored-by:\\s*(?:claude|claude code)\\s*<noreply@anthropic\\.com>\\s*$"
+                "(?i)^\\s*co-authored-by:[^<>]+<noreply@anthropic\\.com>\\s*$"
             ]
         },
         "actions": {
@@ -49,14 +49,14 @@
     },
     {
         "id": "attribution.codex-coauthor",
-        "version": 1,
+        "version": 2,
         "provider": "codex",
         "category": "ai-attribution",
         "confidence": "high",
         "kind": "message",
         "match": {
             "content": [
-                "(?i)^\\s*co-authored-by:\\s*(?:openai\\s+)?codex\\s*<noreply@openai\\.com>\\s*$"
+                "(?i)^\\s*co-authored-by:[^<>]+<noreply@openai\\.com>\\s*$"
             ]
         },
         "actions": {
@@ -95,7 +95,7 @@
     },
     {
         "id": "attribution.generated-with",
-        "version": 1,
+        "version": 2,
         "provider": "generic",
         "category": "ai-attribution",
         "confidence": "high",
@@ -103,7 +103,7 @@
         "match": {
             "content": [
                 "(?i)^\\s*generated\\s+(?:with|by)\\s+(?:claude(?:\\s+code)?|(?:github\\s+)?copilot|chatgpt|gpt(?:-[0-9]+(?:\\.[0-9]+)?)?|(?:openai\\s+)?codex|cursor)[.!]?\\s*$",
-                "(?i)^\\s*(?:🤖\\s*)?generated\\s+with\\s+\\[claude code\\]\\(https://claude\\.ai/code\\)\\s*$"
+                "(?i)^\\s*(?:🤖\\s*)?generated\\s+with\\s+\\[(?:claude(?:\\s+code)?|(?:github\\s+)?copilot|chatgpt|gpt(?:-[0-9]+(?:\\.[0-9]+)?)?|(?:openai\\s+)?codex|cursor)\\]\\([^)]*\\)\\s*$"
             ]
         },
         "actions": {
@@ -126,7 +126,7 @@
         "kind": "message",
         "match": {
             "content": [
-                "(?i)^\\s*[a-z-]+-by:\\s*[^<>]+\\s*<noreply@(anthropic|openai)\\.com>\\s*$"
+                "(?i)^\\s*[a-z-]+-by:[^<>]+<noreply@(anthropic|openai)\\.com>\\s*$"
             ]
         },
         "actions": {

package/src/atomic-write.mjs

@@ -39,7 +39,7 @@ export function atomicWrite(file, data, options = {}) {
         operations.sync(descriptor);
         operations.close(descriptor);
         descriptor = undefined;
-        operations.rename(temporary, file);
+        renameWithRetry(operations, temporary, file, options.renameRetries);
         try {
             syncDirectory(directory, operations);
         } catch (error) {
@@ -57,6 +57,30 @@ export function atomicWrite(file, data, options = {}) {
     }
 }
 
+// Windows fails a rename with EPERM/EACCES/EBUSY while another handle is open on
+// either path — an antivirus or indexer scanning the file aimhooman just wrote is
+// enough, and it clears within milliseconds. Observed on CI as a lock contender
+// dying at its ticket publication, which then read as a lifecycle-queue timeout.
+// The rename is the atomic commit point, so a retry either lands the complete
+// file or leaves the original untouched; it can never publish a partial write.
+// A non-transient error (and every code on other platforms) still throws at once.
+const TRANSIENT_RENAME_CODES = new Set(['EPERM', 'EACCES', 'EBUSY']);
+
+function renameWithRetry(operations, temporary, file, retries = 20) {
+    for (let attempt = 0; ; attempt += 1) {
+        try {
+            operations.rename(temporary, file);
+            return;
+        } catch (error) {
+            const retryable = process.platform === 'win32'
+                && TRANSIENT_RENAME_CODES.has(error?.code)
+                && attempt + 1 < retries;
+            if (!retryable) throw error;
+            waitForLock(5);
+        }
+    }
+}
+
 function existingMode(file) {
     try {
         return statSync(file).mode & 0o777;
@@ -87,6 +111,7 @@ function syncDirectory(directory, operations) {
 }
 
 const LOCK_WAIT_BUFFER = new Int32Array(new SharedArrayBuffer(4));
+const IDENTITY_PROBE_TIMEOUT_MS = 5_000;
 
 function waitForLock(milliseconds) {
     if (milliseconds > 0) Atomics.wait(LOCK_WAIT_BUFFER, 0, 0, milliseconds);
@@ -112,6 +137,12 @@ function processIdentity(pid) {
             const started = execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
                 encoding: 'utf8',
                 stdio: ['ignore', 'pipe', 'ignore'],
+                // This is the only spawn on the lock path, and it runs on macOS
+                // and BSD alone: Linux reads /proc and Windows returns early.
+                // The retry loop below budgets milliseconds per attempt, so a
+                // probe that stalls must lose rather than stretch the loop. A
+                // timeout throws into the catch below, which fails safe.
+                timeout: IDENTITY_PROBE_TIMEOUT_MS,
             }).trim();
             return started ? `ps:${started}` : null;
         }

package/src/git-environment.mjs

@@ -3,3 +3,13 @@
 export function gitEnvironment(environment = process.env) {
     return { ...environment, GIT_NO_REPLACE_OBJECTS: '1' };
 }
+
+// execFileSync has no default timeout, so a git child that never exits blocks
+// the caller forever. One did: it held a CI runner until the platform's 6-hour
+// ceiling killed the job, with no error to read afterwards.
+//
+// Real calls here finish in milliseconds. This bound exists to end a stuck one,
+// not to pace a slow one, so it sits far above any legitimate call: a huge
+// repository on a slow disk stays well inside it, and a hang now raises an
+// error naming the command instead of going quiet.
+export const GIT_TIMEOUT_MS = 120_000;