@rmyndharis/aimhooman 0.1.1 → 0.1.3

package/src/scan-session.mjs

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { gitEnvironment } from './git-environment.mjs';
+import { gitEnvironment, GIT_TIMEOUT_MS } from './git-environment.mjs';
 
 export const DEFAULT_SCAN_LIMITS = Object.freeze({
     maxFileBytes: 2 << 20,
@@ -67,9 +67,11 @@ export function scanEntries(repo, engine, entries, options = {}) {
             increment(stats.skipped, 'binary');
             // Binary classification only skips text-oriented policy rules. Secret
             // signatures are ASCII byte sequences, so latin1 preserves a
-            // one-byte-to-one-code-unit view and prevents one NUL from hiding
-            // credential material while keeping the existing byte limits.
-            matched = engine.checkContent(entry.path, blob.toString('latin1'), {
+            // one-byte-to-one-code-unit view and keeps the existing byte limits.
+            // Stripping NULs is what defeats hiding credential material behind
+            // them: one injected NUL breaks a signature, and a multi-byte
+            // encoding like UTF-16 injects one per character.
+            matched = engine.checkContent(entry.path, blob.toString('latin1').replace(/\0/g, ''), {
                 categories: ['secret'],
             });
         } else {
@@ -112,6 +114,11 @@ function readObjects(repo, objectIds, expectedBytes = 0) {
         input: Buffer.from(unique.join('\n') + '\n'),
         encoding: 'buffer',
         maxBuffer: Math.max(2 * 1024 * 1024, expectedBytes + unique.length * 256 + 1024),
+        timeout: GIT_TIMEOUT_MS,
+        // Same reason as gitBuf in gitx.mjs: without an explicit stdio,
+        // execFileSync echoes the child's stderr before it checks the exit
+        // status, so git's raw output reaches the terminal even on success.
+        stdio: ['pipe', 'pipe', 'pipe'],
     });
     const objects = new Map();
     const failures = [];

package/src/scan-target.mjs

@@ -11,7 +11,16 @@ import { commitChanges, commitMessage, commitSnapshot, historyRange } from './hi
 import { DEFAULT_SCAN_LIMITS, scanEntries } from './scan-session.mjs';
 import { loadRulesWithDiagnostics } from './rules.mjs';
 
-const PROFILE_RANK = { clean: 0, compliance: 1, strict: 2 };
+// A tiebreak for the one profile a range report has to name, not a strength
+// lattice. Clean and compliance are not ordered against each other: compliance
+// allows the six attribution rules clean blocks or reviews, no shipped rule runs
+// the other way, and applyExplicitProfile refuses to move between them in either
+// direction. No single profile is truthful for a mixed range, so this only
+// settles which policy object gets reported — clean outranks compliance because
+// a value read as the strongest must not name the profile that allows what the
+// other blocks. Enforcement never reads this: each commit is scanned under its
+// own policy and the exit code uses each finding's own scanProfile.
+const PROFILE_RANK = { compliance: 0, clean: 1, strict: 2 };
 const REVIEW_REQUIRED_PATH_RULES = new Set([
     'generic.agent-instructions',
     'generic.project-policy',
@@ -49,6 +58,7 @@ export function scanMessage(repo, text, options = {}) {
     const { policy, head } = resolved;
     const loaded = engineForPolicy(repo, policy, options.overrideHead || head);
     const accumulator = createAccumulator(options.limits);
+    accumulator.addSkipped(loaded.skipped);
     accumulator.add(loaded.engine.checkMessage(text).map((finding) => decorate(finding, null, policy)));
     accumulator.addSkipped(loaded.engine.takeSkipped());
     return {
@@ -68,6 +78,7 @@ function scanIndex(repo, options) {
     const { rawPolicy, floor, policy, head, acknowledged } = resolveStagedPolicy(repo, options.explicitProfile);
     const loaded = engineForPolicy(repo, policy, options.overrideHead || head);
     const accumulator = createAccumulator(options.limits);
+    accumulator.addSkipped(loaded.skipped);
     let entries = kind === 'tracked' ? trackedEntries(repo) : stagedEntries(repo);
     const conflicts = unmergedPaths(repo);
     const diagnostics = [...loaded.diagnostics];
@@ -189,6 +200,7 @@ function scanCommit(repo, options) {
         reviewContexts,
     );
     const accumulator = createAccumulator(options.limits);
+    accumulator.addSkipped(loaded.skipped);
     const diagnostics = [...loaded.diagnostics];
 
     if (snapshot.shallowBoundary) {
@@ -261,6 +273,9 @@ function scanRange(repo, options) {
     // only constructs an Engine and applies overrides (see engineForPolicy).
     const preloaded = loadRulesWithDiagnostics(repo.stateDir);
     const preloadedOverrides = loadOverrides(repo.stateDir);
+    // Counted once for the range, not once per commit: the same packs back every
+    // commit's engine, so the per-commit loaded.skipped would inflate the tally.
+    accumulator.addSkipped(packSkipped(preloaded.errors));
 
     for (const commit of history.commits) {
         const changes = commitChanges(repo, commit.commit, commit.commit, commit.parents);
@@ -452,7 +467,14 @@ export function engineForPolicy(
         [...reviewedInstructions, ...reviewedPolicies],
     );
     const diagnostics = loaded.errors.map((error) => ({ level: 'warning', message: `${error.message}; pack skipped` }));
-    return { engine: loaded.engine, diagnostics };
+    return { engine: loaded.engine, diagnostics, skipped: packSkipped(loaded.errors) };
+}
+
+// packSkipped turns rule-pack load failures into a counted skip reason. A pack
+// that never loaded is a hole in coverage, not an empty result: strict throws
+// above, and clean/compliance proceed but must not report a complete scan.
+function packSkipped(errors) {
+    return errors.length ? { 'local-pack-error': errors.length } : {};
 }
 
 function reviewedEngineEntry(entry, ruleId, transition) {
@@ -589,6 +611,10 @@ function rangeReportPolicy(basePolicy, policies, usedStrictFloor, explicitProfil
     };
 }
 
+// Skip reasons that mean a rule never ran, as opposed to a rule running and
+// matching nothing. Either way the scan cannot claim to have covered its input.
+const INCOMPLETE_SKIP_REASONS = new Set(['local-input-limit', 'local-pack-error']);
+
 function createAccumulator(limits = {}) {
     const effectiveLimits = { ...DEFAULT_SCAN_LIMITS, ...limits };
     const findings = [];
@@ -644,7 +670,7 @@ function createAccumulator(limits = {}) {
         addSkipped(skipped = {}) {
             for (const [reason, count] of Object.entries(skipped)) {
                 stats.skipped[reason] = (stats.skipped[reason] || 0) + count;
-                if (reason === 'local-input-limit') complete = false;
+                if (INCOMPLETE_SKIP_REASONS.has(reason)) complete = false;
             }
         },
         markIncomplete() {