pumuki-ast-hooks 5.3.19 → 5.3.21

package/scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js

@@ -53,6 +53,94 @@ function resolveRepoRoot() {
 
 const REPO_ROOT = resolveRepoRoot();
 
+const MCP_LOCK_DIR = path.join(REPO_ROOT, '.audit_tmp', 'mcp-singleton.lock');
+const MCP_LOCK_PID = path.join(MCP_LOCK_DIR, 'pid');
+
+function isPidRunning(pid) {
+    if (!pid || !Number.isFinite(pid) || pid <= 0) return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function safeReadPid(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) return null;
+        const raw = String(fs.readFileSync(filePath, 'utf8') || '').trim();
+        const pid = Number(raw);
+        if (!Number.isFinite(pid) || pid <= 0) return null;
+        return pid;
+    } catch {
+        return null;
+    }
+}
+
+function removeLockDir() {
+    try {
+        if (fs.existsSync(MCP_LOCK_PID)) {
+            fs.unlinkSync(MCP_LOCK_PID);
+        }
+    } catch {
+        // ignore
+    }
+    try {
+        if (fs.existsSync(MCP_LOCK_DIR)) {
+            fs.rmdirSync(MCP_LOCK_DIR);
+        }
+    } catch {
+        // ignore
+    }
+}
+
+function acquireSingletonLock() {
+    try {
+        fs.mkdirSync(path.join(REPO_ROOT, '.audit_tmp'), { recursive: true });
+    } catch {
+        // ignore
+    }
+
+    try {
+        fs.mkdirSync(MCP_LOCK_DIR);
+    } catch (error) {
+        const existingPid = safeReadPid(MCP_LOCK_PID);
+        if (existingPid && isPidRunning(existingPid)) {
+            process.stderr.write(`[MCP] Another instance is already running (pid ${existingPid}). Exiting.\n`);
+            process.exit(0);
+        }
+
+        removeLockDir();
+        fs.mkdirSync(MCP_LOCK_DIR);
+    }
+
+    try {
+        fs.writeFileSync(MCP_LOCK_PID, String(process.pid), { encoding: 'utf8' });
+    } catch {
+        // ignore
+    }
+
+    const cleanup = () => {
+        const pid = safeReadPid(MCP_LOCK_PID);
+        if (pid === process.pid) {
+            removeLockDir();
+        }
+    };
+
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => {
+        cleanup();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        cleanup();
+        process.exit(0);
+    });
+}
+
+acquireSingletonLock();
+
 // Lazy-loaded CompositionRoot - only initialized when first needed
 let _compositionRoot = null;
 function getCompositionRoot() {

package/scripts/hooks-system/infrastructure/orchestration/intelligent-audit.js

@@ -8,9 +8,10 @@ const { TokenManager } = require('../utils/token-manager');
 const { toErrorMessage } = require('../utils/error-utils');
 const fs = require('fs');
 const path = require('path');
+const env = require('../../config/env');
 
 function resolveAuditTmpDir() {
-  const configured = (process.env.AUDIT_TMP || '').trim();
+  const configured = (env.get('AUDIT_TMP', '') || '').trim();
   if (configured.length > 0) {
     return path.isAbsolute(configured) ? configured : path.join(process.cwd(), configured);
   }
@@ -28,7 +29,7 @@ async function runIntelligentAudit() {
     const rawViolations = loadRawViolations();
     console.log(`[Intelligent Audit] Loaded ${rawViolations.length} violations from AST`);
 
-    const gateScope = String(process.env.AI_GATE_SCOPE || 'staging').trim().toLowerCase();
+    const gateScope = String(env.get('AI_GATE_SCOPE', 'staging') || 'staging').trim().toLowerCase();
     const isRepoScope = gateScope === 'repo' || gateScope === 'repository';
 
     let violationsForGate = [];
@@ -212,21 +213,21 @@ function updateAIEvidence(violations, gateResult, tokenUsage) {
     const currentBranch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
 
     const resolveBaseBranch = () => {
-        const configured = process.env.AST_BASE_BRANCH;
-        if (configured && configured.trim().length > 0) {
-            return configured.trim();
-        }
+      const configured = env.get('AST_BASE_BRANCH', '');
+      if (configured && configured.trim().length > 0) {
+        return configured.trim();
+      }
+      try {
+        execSync('git show-ref --verify --quiet refs/heads/develop', { stdio: 'ignore' });
+        return 'develop';
+      } catch {
         try {
-            execSync('git show-ref --verify --quiet refs/heads/develop', { stdio: 'ignore' });
-            return 'develop';
+          execSync('git show-ref --verify --quiet refs/heads/main', { stdio: 'ignore' });
+          return 'main';
         } catch {
-            try {
-                execSync('git show-ref --verify --quiet refs/heads/main', { stdio: 'ignore' });
-                return 'main';
-            } catch {
-                return 'main';
-            }
+          return 'main';
         }
+      }
     };
     const baseBranch = resolveBaseBranch();
     const isProtected = ['main', 'master', baseBranch].includes(currentBranch);
@@ -234,12 +235,12 @@ function updateAIEvidence(violations, gateResult, tokenUsage) {
     const highViolations = violations.filter(v => v.severity === 'HIGH');
     const blockingViolations = [...criticalViolations, ...highViolations].slice(0, 50);
 
-    const gateScope = String(process.env.AI_GATE_SCOPE || 'staging').trim().toLowerCase();
+    const gateScope = String(env.get('AI_GATE_SCOPE', 'staging') || 'staging').trim().toLowerCase();
 
     const existingGate = evidence.ai_gate && typeof evidence.ai_gate === 'object' ? evidence.ai_gate : null;
     let preserveExistingRepoGate = false;
     if (gateScope !== 'repo' && gateScope !== 'repository' && existingGate && existingGate.scope === 'repo' && existingGate.status === 'BLOCKED') {
-      const preserveMs = Number(process.env.AI_GATE_REPO_PRESERVE_MS || 600000);
+      const preserveMs = env.getNumber('AI_GATE_REPO_PRESERVE_MS', 600000);
       const lastCheckMs = Date.parse(existingGate.last_check || '');
       if (!Number.isNaN(preserveMs) && preserveMs > 0 && !Number.isNaN(lastCheckMs)) {
         const ageMs = Date.now() - lastCheckMs;

package/scripts/hooks-system/infrastructure/telemetry/metric-scope.js

@@ -0,0 +1,98 @@
+const { recordMetric } = require('./metrics-logger');
+
+function truncateString(value, maxLen) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    if (!Number.isFinite(maxLen) || maxLen <= 0) {
+        return value;
+    }
+    if (value.length <= maxLen) {
+        return value;
+    }
+    return value.substring(0, maxLen);
+}
+
+function sanitizeMeta(meta, { maxStringLength = 120 } = {}) {
+    if (!meta || typeof meta !== 'object') {
+        return {};
+    }
+
+    const out = {};
+    for (const [k, v] of Object.entries(meta)) {
+        if (v == null) {
+            continue;
+        }
+        if (typeof v === 'string') {
+            out[k] = truncateString(v, maxStringLength);
+            continue;
+        }
+        if (typeof v === 'number' || typeof v === 'boolean') {
+            out[k] = v;
+            continue;
+        }
+        if (v instanceof Error) {
+            out[k] = truncateString(v.message, maxStringLength);
+            continue;
+        }
+
+        try {
+            out[k] = JSON.parse(JSON.stringify(v));
+        } catch {
+            out[k] = truncateString(String(v), maxStringLength);
+        }
+    }
+    return out;
+}
+
+function toErrorMeta(error, { maxStringLength = 160 } = {}) {
+    if (!error) {
+        return {};
+    }
+
+    if (typeof error === 'string') {
+        return { error: truncateString(error, maxStringLength) };
+    }
+
+    const err = error instanceof Error ? error : null;
+    if (!err) {
+        return { error: truncateString(String(error), maxStringLength) };
+    }
+
+    return {
+        error: truncateString(err.message, maxStringLength),
+        errorName: truncateString(err.name, 80)
+    };
+}
+
+function createMetricScope({ hook, operation, baseMeta = {}, options = {} } = {}) {
+    const base = sanitizeMeta({ ...baseMeta }, options);
+
+    const startedAt = Date.now();
+
+    function emit(status, meta = {}) {
+        recordMetric({
+            hook,
+            operation,
+            status,
+            ...base,
+            ...sanitizeMeta(meta, options)
+        });
+    }
+
+    return {
+        started(meta = {}) {
+            emit('started', meta);
+        },
+        success(meta = {}) {
+            emit('success', { durationMs: Date.now() - startedAt, ...meta });
+        },
+        failed(error, meta = {}) {
+            emit('failed', { durationMs: Date.now() - startedAt, ...toErrorMeta(error, options), ...meta });
+        }
+    };
+}
+
+module.exports = {
+    createMetricScope
+};

package/scripts/hooks-system/infrastructure/telemetry/metrics-server.js

@@ -3,9 +3,10 @@
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
+const env = require('../../config/env');
 
-const PORT = Number(process.env.HOOK_METRICS_PORT || 9464);
-const METRICS_FILE = path.join(process.cwd(), '.audit_tmp', 'hook-metrics.jsonl');
+const PORT = env.getNumber('HOOK_METRICS_PORT', 9464);
+const METRICS_FILE = path.join(process.cwd(), env.get('HOOK_METRICS_FILE', '.audit_tmp/hook-metrics.jsonl'));
 
 function loadMetrics() {
   if (!fs.existsSync(METRICS_FILE)) return [];

package/scripts/hooks-system/infrastructure/validators/enforce-english-literals.js

@@ -4,8 +4,9 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const env = require('../../config/env');
 
-const REPO_ROOT = process.env.HOOK_GUARD_REPO_ROOT || process.cwd();
+const REPO_ROOT = env.get('HOOK_GUARD_REPO_ROOT', process.cwd());
 const CONFIG_PATH = path.join(REPO_ROOT, 'scripts', 'hooks-system', 'config', 'language-guard.json');
 const DEFAULT_IGNORED_SEGMENTS = [
     `${path.sep}node_modules${path.sep}`,
@@ -22,7 +23,7 @@ function decodeUnicode(value) {
     try {
         return JSON.parse(`"${value}"`);
     } catch (error) {
-        if (process.env.NODE_ENV === 'development' || process.env.DEBUG) {
+        if (env.isDev || env.getBool('DEBUG', false)) {
             console.debug(`[enforce-english-literals] Failed to decode Unicode value "${value}": ${error.message}`);
         }
         return value;
@@ -119,13 +120,10 @@ function analyzeFile(relativePath, config) {
 
 function collectStagedFiles() {
     try {
-        const raw = execSync('git diff --cached --name-only --diff-filter=ACMR', {
-            cwd: REPO_ROOT,
-            encoding: 'utf8'
-        });
-        return raw.split('\n').map(entry => entry.trim()).filter(Boolean);
+        const stagedFilesRaw = execSync('git diff --cached --name-only', { encoding: 'utf8' });
+        return stagedFilesRaw.split('\n').filter(Boolean).map(file => file.trim());
     } catch (error) {
-        if (process.env.NODE_ENV === 'development' || process.env.DEBUG) {
+        if (env.isDev || env.getBool('DEBUG', false)) {
             console.debug(`[enforce-english-literals] Failed to collect staged files: ${error.message}`);
         }
         return [];