@rmyndharis/aimhooman 0.2.0 → 0.3.1

package/src/scan.mjs

@@ -19,7 +19,6 @@ export class Engine {
         this.rules = rules;
         this.allowPaths = new Set();
         this.allowRules = new Set();
-        this.allowSecretPaths = new Set();
         this.denyPaths = new Set();
         this.denyRules = new Set();
         this.scopedAllow = [];
@@ -33,7 +32,6 @@ export class Engine {
         const denied = this.#splitOverrides(deny);
         this.allowPaths = allowed.paths;
         this.allowRules = allowed.rules;
-        this.allowSecretPaths = allowed.secretPaths;
         this.denyPaths = denied.paths;
         this.denyRules = denied.rules;
         this.scopedAllow = scopedAllow.filter((entry) => (
@@ -59,8 +57,8 @@ export class Engine {
         //   - clean/compliance: review is ADVISORY (a stderr message, exit 0),
         //     so re-surfacing it on every edit of a reviewed agent-instruction
         //     file (CLAUDE.md, AGENTS.md) is pure friction with no security
-        //     payoff — the security boundary is secret scanning, strict blocks,
-        //     and reference-transaction. A LIVE-FILE review (newObjectId set)
+        //     payoff — the security boundary is strict blocks and the
+        //     reference-transaction guard. A LIVE-FILE review (newObjectId set)
         //     therefore persists per path + rule across edits. A TOMBSTONE
         //     review (newObjectId null — a reviewed deletion) keeps the exact
         //     match in every profile: a deletion review must not silently cover
@@ -80,20 +78,13 @@ export class Engine {
                     && entry.newObjectId === context.objectId
                     && entry.newMode === context.mode);
         })) return 'allow';
-        // A rule-level allow cannot bypass the secret-category guard that the
-        // path-level allow below enforces: secret rules require an explicit
-        // --scope secret-path override on a specific path, never a blanket rule allow.
-        if (this.allowRules.has(rule.id) && rule.category !== 'secret') return 'allow';
-        // A --scope secret-path allow is the explicit override for secret-category
-        // rules only; it must not also suppress a non-secret rule that happens to
-        // match the same path (principle of least privilege).
-        if (this.allowSecretPaths.has(target) && rule.category === 'secret') return 'allow';
-        if (this.allowPaths.has(target) && rule.category !== 'secret') return 'allow';
+        if (this.allowRules.has(rule.id)) return 'allow';
+        if (this.allowPaths.has(target)) return 'allow';
         return base;
     }
 
     #splitOverrides(entries) {
-        const result = { paths: new Set(), rules: new Set(), secretPaths: new Set() };
+        const result = { paths: new Set(), rules: new Set() };
         for (const entry of entries || []) {
             const target = typeof entry === 'string' ? entry : entry?.target;
             if (!target) continue;
@@ -101,7 +92,6 @@ export class Engine {
                 ? (this.lookup(target) ? 'rule' : 'path')
                 : (entry.scope ?? (this.lookup(target) ? 'rule' : 'path'));
             if (scope === 'rule') result.rules.add(target);
-            else if (scope === 'secret-path') result.secretPaths.add(target);
             else if (scope === 'path') result.paths.add(target);
         }
         return result;
@@ -138,13 +128,10 @@ export class Engine {
     checkContent(path, content, options = {}) {
         const out = [];
         const p = normalize(path);
-        const categories = Array.isArray(options.categories)
-            ? new Set(options.categories)
-            : null;
         // lineRanges narrows content scanning to changed hunks (W4, bug 12d-F1).
         // When provided (an array of inclusive 1-based {start,end} ranges), only
         // lines falling in a range are evaluated; this stops a file that contains
-        // a secret-bearing line ELSEWHERE (a PEM header inside a test string on
+        // a flagged line ELSEWHERE (a marker phrase inside a test fixture on
         // line 200) from blocking a commit that only edited line 50. Findings
         // keep their real line numbers because lineRecords already anchors them.
         // Absent = scan every line (the pre-W4 behaviour).
@@ -153,8 +140,8 @@ export class Engine {
             : null;
         for (const record of lineRecords(String(content))) {
             if (ranges && !ranges.some((range) => record.line >= range.start && record.line <= range.end)) continue;
-            this.#markLocalInputSkip('code', p, record.text, categories);
-            const result = this.#evaluate('code', p, record.text, { categories });
+            this.#markLocalInputSkip('code', p, record.text);
+            const result = this.#evaluate('code', p, record.text);
             if (result) out.push(finding(result, { path: p, line: record.line, text: record.text }));
         }
         return out;
@@ -198,11 +185,10 @@ export class Engine {
         return skipped;
     }
 
-    #markLocalInputSkip(kind, target, text, categories = null) {
+    #markLocalInputSkip(kind, target, text) {
         if (text.length <= MAX_LOCAL_MATCH_INPUT) return;
         const applicable = this.rules.some((rule) => {
             if (rule.source !== 'local' || rule.kind !== kind) return false;
-            if (categories && !categories.has(rule.category)) return false;
             if (kind !== 'code') return true;
             const candidate = rule.pathCaseInsensitive ? target.toLowerCase() : target;
             if (rule.pathRes.length && !rule.pathRes.some((regexp) => regexp.test(candidate))) return false;
@@ -216,7 +202,6 @@ export class Engine {
         for (const rule of this.rules) {
             if (rule.kind !== kind) continue;
             if (context.excludedRuleIds?.has(rule.id)) continue;
-            if (context.categories && !context.categories.has(rule.category)) continue;
             const matched = kind === 'path'
                 ? matchesPath(rule, target)
                 : matchesContent(rule, text, kind === 'code' ? target : undefined);

package/src/state.mjs

@@ -4,14 +4,14 @@ import {
     readFileSync,
 } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { atomicWrite } from './atomic-write.mjs';
+import { atomicWrite, withLock } from './atomic-write.mjs';
 import { normalizeGitPath } from './git-path.mjs';
 
 // Per-repository state, stored in the common Git dir (never the worktree).
 
 const PROFILES = new Set(['clean', 'strict', 'compliance']);
 const OVERRIDE_SCOPES = new Set([
-    'path', 'rule', 'secret-path', 'reviewed-instruction', 'reviewed-policy-file', 'policy-migration',
+    'path', 'rule', 'reviewed-instruction', 'reviewed-policy-file', 'policy-migration',
 ]);
 const OVERRIDE_FIELDS = new Set([
     'target', 'scope', 'reason', 'actor', 'at', 'head', 'transition', 'oldObjectId', 'newObjectId', 'newMode',
@@ -105,8 +105,20 @@ export function parseProjectPolicy(text, file = '.aimhooman.json') {
 
 export function loadConfig(stateDir, root) {
     const project = loadProjectPolicy(root);
-    if (project) return { profile: project.profile, source: 'project', file: project.file };
     const file = join(stateDir, 'config.json');
+    if (project) {
+        // The project policy owns the profile, but the --gitignore opt-in stays
+        // per-clone state in config.json; a two-arg caller still needs it. The
+        // profile no longer depends on that file here, so a missing or corrupt
+        // one just omits the record instead of failing the load.
+        const gitignore = readGitignoreRecord(file);
+        return {
+            profile: project.profile,
+            source: 'project',
+            file: project.file,
+            ...(gitignore ? { gitignore } : {}),
+        };
+    }
     let text;
     try {
         text = readFileSync(file, 'utf8');
@@ -121,20 +133,40 @@ export function loadConfig(stateDir, root) {
         throw new LocalConfigError(file, `invalid JSON: ${error.message}`, error);
     }
     const normalized = normalizeLocalConfig(config, file);
-    return { profile: normalized.profile, source: 'local', file };
+    return {
+        profile: normalized.profile,
+        source: 'local',
+        file,
+        ...(normalized.gitignore ? { gitignore: normalized.gitignore } : {}),
+    };
+}
+
+// Best-effort read of the per-clone gitignore record for the project-policy
+// branch above: any failure (absent file, invalid JSON, invalid shape) means
+// no record, never a failed load.
+function readGitignoreRecord(file) {
+    try {
+        return normalizeLocalConfig(JSON.parse(stripBom(readFileSync(file, 'utf8'))), file).gitignore;
+    } catch {
+        return undefined;
+    }
 }
 
 export function saveConfig(stateDir, config) {
     const file = join(stateDir, 'config.json');
     const normalized = normalizeLocalConfig(config, file);
-    atomicWriteJson(file, { schema_version: 1, profile: normalized.profile });
+    atomicWriteJson(file, {
+        schema_version: 1,
+        profile: normalized.profile,
+        ...(normalized.gitignore ? { gitignore: normalized.gitignore } : {}),
+    });
 }
 
 function normalizeLocalConfig(config, file) {
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
         throw new LocalConfigError(file, 'root must be a JSON object');
     }
-    const unknown = Object.keys(config).filter((key) => !['schema_version', 'profile'].includes(key));
+    const unknown = Object.keys(config).filter((key) => !['schema_version', 'profile', 'gitignore'].includes(key));
     if (unknown.length) {
         throw new LocalConfigError(file, `unsupported field${unknown.length === 1 ? '' : 's'}: ${unknown.join(', ')}`);
     }
@@ -147,7 +179,32 @@ function normalizeLocalConfig(config, file) {
     if (!PROFILES.has(config.profile)) {
         throw new LocalConfigError(file, 'profile must be clean, strict, or compliance');
     }
-    return { profile: config.profile };
+    const gitignore = normalizeGitignoreConfig(config.gitignore, file);
+    return { profile: config.profile, ...(gitignore ? { gitignore } : {}) };
+}
+
+// The gitignore field records an `init --gitignore` opt-in for this clone:
+// enabled says the worktree .gitignore carries our managed block, created says
+// the file did not exist before we wrote it (so uninstall may delete a file we
+// introduced once the block leaves it empty). It stays out of the project
+// policy on purpose — whether this clone created its .gitignore is per-clone
+// state, never team policy. Absent means disabled, and a disabled record
+// normalizes away so the two spellings cannot drift apart.
+function normalizeGitignoreConfig(value, file) {
+    if (value === undefined) return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new LocalConfigError(file, 'gitignore must be an object');
+    }
+    const unknown = Object.keys(value).filter((key) => !['enabled', 'created'].includes(key));
+    if (unknown.length) {
+        throw new LocalConfigError(file, `gitignore has unsupported field${unknown.length === 1 ? '' : 's'}: ${unknown.join(', ')}`);
+    }
+    for (const field of ['enabled', 'created']) {
+        if (typeof value[field] !== 'boolean') {
+            throw new LocalConfigError(file, `gitignore.${field} must be a boolean`);
+        }
+    }
+    return value.enabled ? { enabled: true, created: value.created } : undefined;
 }
 
 export function loadOverrides(stateDir) {
@@ -159,7 +216,28 @@ export function loadOverrides(stateDir) {
         if (error?.code === 'ENOENT') return { allow: [], deny: [] };
         throw new LocalOverridesError(file, `cannot read file: ${error.message}`, error);
     }
-    return parseOverrides(text, file);
+    const dropped = { count: 0 };
+    const overrides = parseOverrides(text, file, dropped);
+    if (dropped.count) {
+        process.stderr.write(
+            `aimhooman: warning: ${file}: dropped ${dropped.count} override(s) with retired scope "secret-path"; built-in secret scanning was removed in v0.3.0\n`
+        );
+        // Persist the cleaned file so the migration warns once, not on every
+        // command. Re-read under the lock so a concurrent allow/deny write is
+        // never clobbered; a failed rewrite only means the warning returns
+        // next run, so this stays best effort. One attempt, no queue wait:
+        // allow/deny/override/review/policy-review call loadOverrides while
+        // already holding this same lock, and the bakery queue would park the
+        // inner candidate behind the outer one for the full retry budget
+        // before the catch below swallowed the throw.
+        try {
+            withLock(`${file}.lock`, () => {
+                const fresh = parseOverrides(readFileSync(file, 'utf8'), file);
+                atomicWriteJson(file, { schema_version: 1, ...fresh });
+            }, { retries: 1 });
+        } catch { /* best effort */ }
+    }
+    return overrides;
 }
 
 export function saveOverrides(stateDir, overrides) {
@@ -173,17 +251,17 @@ export function normalizeOverrideTarget(target) {
     return normalizeGitPath(target);
 }
 
-function parseOverrides(text, file) {
+function parseOverrides(text, file, dropped = { count: 0 }) {
     let value;
     try {
         value = JSON.parse(stripBom(text));
     } catch (error) {
         throw new LocalOverridesError(file, `invalid JSON: ${error.message}`, error);
     }
-    return normalizeOverrides(value, file);
+    return normalizeOverrides(value, file, dropped);
 }
 
-function normalizeOverrides(value, file) {
+function normalizeOverrides(value, file, dropped = { count: 0 }) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new LocalOverridesError(file, 'root must be a JSON object');
     }
@@ -196,18 +274,29 @@ function normalizeOverrides(value, file) {
     if (value.schema_version !== undefined && value.schema_version !== 1) {
         throw new LocalOverridesError(file, 'schema_version must be 1');
     }
+    // The caller owns the drop count: loadOverrides warns and persists the
+    // cleaned file, saveOverrides drops retired entries silently on the next
+    // write.
     return {
-        allow: overrideEntries(value.allow, 'allow', file),
-        deny: overrideEntries(value.deny, 'deny', file),
+        allow: overrideEntries(value.allow, 'allow', file, dropped),
+        deny: overrideEntries(value.deny, 'deny', file, dropped),
     };
 }
 
-function overrideEntries(value, key, file) {
+function overrideEntries(value, key, file, dropped = { count: 0 }) {
     if (value === undefined) return [];
     if (!Array.isArray(value)) {
         throw new LocalOverridesError(file, `${key} must be an array`);
     }
     return value.map((entry, index) => {
+        // Built-in secret scanning and its secret-path override scope were
+        // removed in v0.3.0. An overrides file written by an older version may
+        // still carry such entries; drop them (loadOverrides warns once and
+        // persists the cleaned file) instead of failing the whole load.
+        if (entry && typeof entry === 'object' && !Array.isArray(entry) && entry.scope === 'secret-path') {
+            dropped.count += 1;
+            return null;
+        }
         if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
             throw new LocalOverridesError(file, `${key}[${index}] must be an object`);
         }
@@ -260,7 +349,7 @@ function overrideEntries(value, key, file) {
             normalized.transition = normalized.transition.toLowerCase();
         }
         return normalized;
-    });
+    }).filter((entry) => entry !== null);
 }
 
 function isRfc3339DateTime(value) {

package/rules/secrets.json

@@ -1,96 +0,0 @@
-[
-    {
-        "id": "secret.private-key-content",
-        "version": 1,
-        "provider": "generic",
-        "category": "secret",
-        "confidence": "high",
-        "kind": "code",
-        "match": {
-            "content": [
-                "-----BEGIN (?:ENCRYPTED |RSA |DSA |EC |OPENSSH |PGP )?PRIVATE KEY(?: BLOCK)?-----"
-            ]
-        },
-        "actions": {
-            "clean": "block",
-            "strict": "block",
-            "compliance": "block"
-        },
-        "reason": "Private-key material must not enter Git history.",
-        "remediation": [
-            "Remove the key from the index, rotate it if exposed, and store it outside the repository.",
-            "If this is an intentional fixture, run: aimhooman allow <path> --scope secret-path --reason \"test fixture\"."
-        ]
-    },
-    {
-        "id": "secret.service-account-key",
-        "version": 1,
-        "provider": "generic",
-        "category": "secret",
-        "confidence": "high",
-        "kind": "code",
-        "match": {
-            "content": [
-                "(?i)\\\"private_key\\\"\\s*:\\s*\\\"-----BEGIN (?:RSA )?PRIVATE KEY-----"
-            ]
-        },
-        "actions": {
-            "clean": "block",
-            "strict": "block",
-            "compliance": "block"
-        },
-        "reason": "A service-account credential must not enter Git history.",
-        "remediation": [
-            "Remove the credential from the index, rotate it if exposed, and use the service's secret store.",
-            "If this is an intentional fixture, run: aimhooman allow <path> --scope secret-path --reason \"test fixture\"."
-        ]
-    },
-    {
-        "id": "secret.aws-key-content",
-        "version": 3,
-        "provider": "aws",
-        "category": "secret",
-        "confidence": "high",
-        "kind": "code",
-        "match": {
-            "content": [
-                "(?i)\\baws_(?:secret_access_key|session_token)\\b\\s*[:=]\\s*[\\\"']?[A-Za-z0-9/+=]{32,}(?<!EXAMPLEKEY)(?![A-Za-z0-9/+=])",
-                "\\b(?:AKIA|ASIA)(?![A-Z0-9]{9}EXAMPLE\\b)[A-Z0-9]{16}\\b"
-            ]
-        },
-        "actions": {
-            "clean": "block",
-            "strict": "block",
-            "compliance": "block"
-        },
-        "reason": "AWS credential material must not enter Git history.",
-        "remediation": [
-            "Remove the credential from the index, rotate it if exposed, and use an AWS credential provider.",
-            "If this is an intentional fixture, run: aimhooman allow <path> --scope secret-path --reason \"test fixture\"."
-        ]
-    },
-    {
-        "id": "secret.provider-token",
-        "version": 1,
-        "provider": "generic",
-        "category": "secret",
-        "confidence": "high",
-        "kind": "code",
-        "match": {
-            "content": [
-                "\\b(?:gh[pousr]_[A-Za-z0-9]{36,255}|github_pat_[A-Za-z0-9_]{60,255}|glpat-[A-Za-z0-9_-]{20,255}|npm_[A-Za-z0-9]{36,255}|xox[baprs]-[A-Za-z0-9-]{20,255})\\b",
-                "\\b(?:sk-ant-api[0-9]{2}-[A-Za-z0-9_-]{80,255}|sk-proj-[A-Za-z0-9_-]{40,255}|AIza[A-Za-z0-9_-]{35}|(?:sk|rk)_live_[A-Za-z0-9]{20,255}|hf_[A-Za-z0-9]{34}|SG\\.[A-Za-z0-9_-]{20,255}\\.[A-Za-z0-9_-]{40,255})\\b"
-            ]
-        },
-        "actions": {
-            "clean": "block",
-            "strict": "block",
-            "compliance": "block"
-        },
-        "reason": "A provider access token must not enter Git history.",
-        "remediation": [
-            "Remove the token from the index, revoke or rotate it, and use the provider's secret store.",
-            "If this is an intentional fixture, run: aimhooman allow <path> --scope secret-path --reason \"test fixture\"."
-        ]
-    }
-]