agentic-workflow-manager 2.0.0

package/dist/src/commands/sensors/baseline.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprint = fingerprint;
+exports.readBaseline = readBaseline;
+exports.writeBaseline = writeBaseline;
+exports.partition = partition;
+exports.buildBaseline = buildBaseline;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const BASELINE_FILE = path_1.default.join('.awm', 'sensors.baseline.json');
+/**
+ * Mask runs of digits so location noise embedded in messages (e.g. the tsc
+ * formatter writes "... line 199 ...") doesn't change the fingerprint when code
+ * shifts. Line/column fields are excluded from the fingerprint for the same reason.
+ */
+function maskNumbers(s) {
+    return s.replace(/\d+/g, '#');
+}
+/**
+ * Identity of a finding, for matching against the accepted baseline.
+ *
+ * The basis deliberately EXCLUDES the human-readable message when a `rule` id is
+ * present (every real sensor — eslint `ruleId`, tsc error code, semgrep
+ * `check_id` — sets one). The message text is volatile: it changes with tool
+ * version bumps and rule-config tweaks (e.g. adding `argsIgnorePattern` makes
+ * eslint append "Allowed unused args must match ...").  When the message was
+ * part of the basis, any such change re-fingerprinted every existing finding, so
+ * the whole baseline silently went stale and reported hundreds of false "new"
+ * findings. Keying on `sensor|file|rule` makes the baseline immune to wording
+ * changes; occurrence counts (see `partition`) keep it precise.
+ *
+ * Findings without a rule (the generic formatter) fall back to the masked
+ * message, preserving the previous behaviour for that case.
+ */
+function fingerprint(sensor, e) {
+    const basis = e.rule
+        ? `${sensor}|${e.file ?? ''}|${e.rule}`
+        : `${sensor}|${e.file ?? ''}|${maskNumbers(e.message)}`;
+    return crypto_1.default.createHash('sha1').update(basis).digest('hex');
+}
+function readBaseline(cwd) {
+    const p = path_1.default.join(cwd, BASELINE_FILE);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeBaseline(cwd, baseline) {
+    fs_1.default.mkdirSync(path_1.default.join(cwd, '.awm'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(cwd, BASELINE_FILE), JSON.stringify(baseline, null, 2), 'utf-8');
+}
+/**
+ * Split a sensor's findings into new vs baseline-suppressed. With no accepted
+ * set, every finding is new (backward-compatible: no baseline file → current behavior).
+ */
+function partition(sensor, errors, accepted) {
+    if (!accepted || accepted.length === 0)
+        return { newErrors: errors, suppressed: 0 };
+    // Count-based matching: the baseline holds one fingerprint per accepted
+    // occurrence (duplicates allowed). A finding is suppressed only while there's
+    // remaining "budget" for its fingerprint. This is what closes the gap left by
+    // keying on `sensor|file|rule` alone — if a file had 3 accepted findings of a
+    // rule and now has 5, the 2 extra are correctly reported as new.
+    const remaining = new Map();
+    for (const fp of accepted)
+        remaining.set(fp, (remaining.get(fp) ?? 0) + 1);
+    const newErrors = [];
+    for (const e of errors) {
+        const fp = fingerprint(sensor, e);
+        const budget = remaining.get(fp) ?? 0;
+        if (budget > 0)
+            remaining.set(fp, budget - 1);
+        else
+            newErrors.push(e);
+    }
+    return { newErrors, suppressed: errors.length - newErrors.length };
+}
+/** Snapshot the current findings of a full run as the accepted baseline. */
+function buildBaseline(results) {
+    const baseline = {};
+    for (const r of results) {
+        baseline[r.name] = r.errors.map(e => fingerprint(r.name, e));
+    }
+    return baseline;
+}

package/dist/src/commands/sensors/formatters/eslint.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEslintOutput = parseEslintOutput;
+function parseEslintOutput(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const errors = [];
+    const cwd = process.cwd();
+    for (const file of parsed) {
+        for (const msg of file.messages) {
+            if (msg.severity < 2 || msg.line == null || msg.column == null)
+                continue;
+            const rel = file.filePath.startsWith(cwd + '/') ? file.filePath.slice(cwd.length + 1) : file.filePath;
+            errors.push({
+                file: rel,
+                line: msg.line,
+                column: msg.column,
+                rule: msg.ruleId ?? 'unknown',
+                message: `SENSOR[lint] ${rel}:${msg.line} — ${msg.message} Fix: check rule ${msg.ruleId ?? 'unknown'}.`,
+            });
+        }
+    }
+    return errors;
+}

package/dist/src/commands/sensors/formatters/generic.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGenericOutput = parseGenericOutput;
+function parseGenericOutput(raw) {
+    if (!raw.trim())
+        return [];
+    return [{ message: `SENSOR[raw] ${raw.trim()}` }];
+}

package/dist/src/commands/sensors/formatters/semgrep.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSemgrepOutput = parseSemgrepOutput;
+function parseSemgrepOutput(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    return (parsed.results ?? []).map(r => ({
+        file: r.path,
+        line: r.start?.line ?? 0,
+        rule: r.check_id,
+        message: `SENSOR[security] ${r.path}:${r.start?.line ?? '?'} — ${r.extra?.message ?? 'unknown'} Fix: review rule ${r.check_id}.`,
+    }));
+}

package/dist/src/commands/sensors/formatters/test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTestOutput = parseTestOutput;
+/**
+ * Tests are an exit-code sensor: the runner's exit status IS the signal, not the
+ * parsed output. A passing run prints output ("6 passed") that must NOT be treated
+ * as findings — so the success path yields no errors. The failure path (non-zero
+ * exit) is handled in runSensor via isExitCodeSensor, not here.
+ */
+function parseTestOutput(_raw) {
+    return [];
+}

package/dist/src/commands/sensors/formatters/tsc.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTscOutput = parseTscOutput;
+const TSC_LINE = /^(.+)\((\d+),(\d+)\): error (TS\d+): (.+)$/;
+function parseTscOutput(raw) {
+    const errors = [];
+    for (const line of raw.split('\n')) {
+        if (!line)
+            continue;
+        const m = TSC_LINE.exec(line);
+        if (!m)
+            continue;
+        const [, file, lineStr, colStr, code, msg] = m;
+        errors.push({
+            file,
+            line: parseInt(lineStr, 10),
+            column: parseInt(colStr, 10),
+            rule: code,
+            message: `SENSOR[typecheck] ${file} line ${lineStr} — ${msg} Fix: review the type annotation. Error code: ${code}.`,
+        });
+    }
+    return errors;
+}

package/dist/src/commands/sensors/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exitCodeFor = exitCodeFor;
+exports.registerSensorsCommand = registerSensorsCommand;
+const picocolors_1 = __importDefault(require("picocolors"));
+const prompts_1 = require("@clack/prompts");
+const run_1 = require("./run");
+const init_1 = require("./init");
+const status_1 = require("./status");
+const install_1 = require("./install");
+const baseline_1 = require("./baseline");
+const registries_1 = require("../../core/registries");
+/** Map a sensor run verdict to a process exit code. fail → 1; everything else → 0.
+ *  not_certified intentionally exits 0: its signal lives in `overall`, because
+ *  exit code 2 is a blocking error in Claude Code hooks. */
+function exitCodeFor(output) {
+    return output.overall === 'fail' ? 1 : 0;
+}
+function registerSensorsCommand(program) {
+    const sensors = program.command('sensors').description('manage computational sensors for the current project');
+    sensors
+        .command('run')
+        .description('run sensors from .awm/sensors.json')
+        .option('--fast', 'run fast sensors only (tsc, lint)')
+        .option('--slow', 'run slow sensors only (semgrep, mutation)')
+        .option('--all', 'run all sensors regardless of speed')
+        .action((opts) => {
+        const output = (0, run_1.runSensors)({ fast: opts.fast, slow: opts.slow, all: opts.all });
+        // Emit the verdict ALWAYS — an empty `sensors` with overall:'not_certified'
+        // must be visible, never a silent exit-0 that reads as "clean".
+        process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+        const code = exitCodeFor(output);
+        if (code !== 0)
+            process.exit(code);
+    });
+    sensors
+        .command('init')
+        .description('detect stack and write .awm/sensors.json (+ copy pack config files)')
+        .option('--no-configure', 'skip copying sensor pack config files into the project')
+        .option('--registry-root <path>', 'path to AWM registry root')
+        .action((opts) => {
+        const registryRoot = opts.registryRoot ?? (0, registries_1.capabilityRoot)('sensor-packs') ?? undefined;
+        const result = (0, init_1.initSensors)({ configure: opts.configure, registryRoot });
+        prompts_1.log.success(`Detected: ${result.detection.pack} (${result.detection.indicators.join(', ') || 'fallback'})`);
+        prompts_1.log.success('Wrote .awm/sensors.json');
+        result.configured.forEach((f) => prompts_1.log.info(`  Installed ${f}`));
+    });
+    sensors
+        .command('baseline')
+        .description('snapshot current findings as accepted — sensors then fail only on NEW ones')
+        .action(() => {
+        const manifestDir = (0, run_1.findManifestDir)(process.cwd());
+        const output = (0, run_1.runSensors)({ all: true, ignoreBaseline: true });
+        const baseline = (0, baseline_1.buildBaseline)(output.sensors.map(s => ({ name: s.name, errors: s.errors })));
+        const writeDir = manifestDir ?? process.cwd();
+        (0, baseline_1.writeBaseline)(writeDir, baseline);
+        const total = Object.values(baseline).reduce((n, fps) => n + fps.length, 0);
+        prompts_1.log.success(`Baseline guardado: ${total} hallazgos aceptados en .awm/sensors.baseline.json`);
+        prompts_1.log.info('Los sensors ahora fallan solo ante hallazgos nuevos. Re-corré `awm sensors baseline` tras reducir deuda.');
+    });
+    sensors
+        .command('status')
+        .description('check sensor health for the current project')
+        .action(() => {
+        const status = (0, status_1.computeSensorStatus)();
+        const icon = status.overall === 'HEALTHY' ? picocolors_1.default.green('✔') : picocolors_1.default.yellow('⚠');
+        console.log(`\nPack:    ${status.pack ?? 'none'}`);
+        console.log(`Overall: ${icon} ${status.overall}\n`);
+        for (const [name, check] of Object.entries(status.checks)) {
+            const mark = check.ok ? picocolors_1.default.green('✔') : picocolors_1.default.red('✘');
+            console.log(`  ${mark}  ${name.padEnd(12)} ${check.detail}`);
+        }
+        console.log('');
+        if (status.overall !== 'HEALTHY')
+            process.exit(1);
+    });
+    sensors
+        .command('install')
+        .description('install PostToolUse hook in ~/.claude/settings.json')
+        .action(() => {
+        const result = (0, install_1.installSensorHook)();
+        if (result.status === 'already-installed') {
+            prompts_1.log.info('PostToolUse hook already installed.');
+        }
+        else {
+            prompts_1.log.success('PostToolUse hook installed in ~/.claude/settings.json');
+            if (result.backupPath)
+                prompts_1.log.info(`  Backup: ${result.backupPath}`);
+        }
+    });
+}

package/dist/src/commands/sensors/init.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectStack = detectStack;
+exports.detectSourceDirs = detectSourceDirs;
+exports.buildManifest = buildManifest;
+exports.initSensors = initSensors;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const STACK_DETECTORS = [
+    { pack: 'js-ts', files: ['package.json'] },
+    { pack: 'python', files: ['pyproject.toml', 'setup.py', 'setup.cfg'] },
+];
+function detectStack(cwd) {
+    for (const { pack, files } of STACK_DETECTORS) {
+        const found = files.filter(f => fs_1.default.existsSync(path_1.default.join(cwd, f)));
+        if (found.length > 0)
+            return { pack, indicators: found };
+    }
+    return { pack: 'generic', indicators: [] };
+}
+// Candidate source dirs in priority order. `depcheck` analyzes the ones that
+// exist — a project may use `src/`, or App-Router-style `app/lib/components/...`.
+const SOURCE_DIR_CANDIDATES = ['src', 'app', 'lib', 'components', 'hooks', 'pages'];
+function detectSourceDirs(cwd) {
+    const found = SOURCE_DIR_CANDIDATES.filter(d => {
+        const p = path_1.default.join(cwd, d);
+        return fs_1.default.existsSync(p) && fs_1.default.statSync(p).isDirectory();
+    });
+    return found.length > 0 ? found : ['src'];
+}
+// Fallback defaults for packs that don't yet ship a pack.json in the registry
+// (today: python). js-ts/generic are sourced from
+// registry/sensor-packs/<pack>/pack.json — single source of truth.
+const FALLBACK_DEFAULTS = {
+    python: {
+        typecheck: { cmd: 'mypy .', fast: true },
+        lint: { cmd: 'ruff check . --output-format json', fast: true },
+        security: { cmd: 'semgrep --config .semgrep.awm.yml --json .', fast: false },
+        mutation: { enabled: false },
+    },
+};
+/**
+ * Read sensor defaults from the pack's pack.json (the single source of truth).
+ * Maps `defaultCmd` → `cmd` and substitutes the `{{SOURCE_DIRS}}` placeholder
+ * with the project's actual source dirs. Returns null if the pack has no pack.json.
+ */
+function readPackDefaults(pack, registryRoot, cwd) {
+    const packJsonPath = path_1.default.join(registryRoot, 'sensor-packs', pack, 'pack.json');
+    if (!fs_1.default.existsSync(packJsonPath))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(packJsonPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const sourceDirs = detectSourceDirs(cwd).join(' ');
+    const sensors = {};
+    for (const [name, def] of Object.entries(parsed.sensors ?? {})) {
+        const entry = {};
+        if (def.defaultCmd)
+            entry.cmd = def.defaultCmd.replace('{{SOURCE_DIRS}}', sourceDirs);
+        if (def.fast !== undefined)
+            entry.fast = def.fast;
+        if (def.enabled !== undefined)
+            entry.enabled = def.enabled;
+        sensors[name] = entry;
+    }
+    return sensors;
+}
+function buildManifest(pack, existing, registryRoot, cwd = process.cwd()) {
+    const fromPack = registryRoot ? readPackDefaults(pack, registryRoot, cwd) : null;
+    const defaults = fromPack ?? FALLBACK_DEFAULTS[pack] ?? {};
+    const existingSensors = existing?.sensors ?? {};
+    return { pack, sensors: { ...defaults, ...existingSensors } };
+}
+function initSensors(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const configure = opts.configure ?? true; // configure (copy pack config files) by default
+    const manifestPath = path_1.default.join(cwd, '.awm', 'sensors.json');
+    const detection = detectStack(cwd);
+    let existing;
+    if (fs_1.default.existsSync(manifestPath)) {
+        try {
+            existing = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        }
+        catch { /* ignore corrupt manifest */ }
+    }
+    const manifest = buildManifest(detection.pack, existing, opts.registryRoot, cwd);
+    fs_1.default.mkdirSync(path_1.default.join(cwd, '.awm'), { recursive: true });
+    const tmpPath = manifestPath + '.tmp';
+    fs_1.default.writeFileSync(tmpPath, JSON.stringify(manifest, null, 2), 'utf-8');
+    fs_1.default.renameSync(tmpPath, manifestPath);
+    const configured = [];
+    if (configure && opts.registryRoot) {
+        const packDir = path_1.default.join(opts.registryRoot, 'sensor-packs', detection.pack);
+        if (fs_1.default.existsSync(packDir)) {
+            for (const file of fs_1.default.readdirSync(packDir).filter(f => f !== 'pack.json')) {
+                const dst = path_1.default.join(cwd, file);
+                if (!fs_1.default.existsSync(dst)) {
+                    fs_1.default.copyFileSync(path_1.default.join(packDir, file), dst);
+                    configured.push(file);
+                }
+            }
+        }
+    }
+    return { manifest, detection, configured };
+}

package/dist/src/commands/sensors/install.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSensorHook = installSensorHook;
+exports.uninstallSensorHook = uninstallSensorHook;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const POST_TOOL_USE_EVENT = 'PostToolUse';
+const POST_TOOL_USE_MATCHER = 'Write|Edit|MultiEdit';
+const AWM_SENSOR_CMD = 'awm sensors run --fast';
+function defaultSettingsPath() {
+    return path_1.default.join(process.env.HOME ?? os_1.default.homedir(), '.claude', 'settings.json');
+}
+function readSettings(p) {
+    if (!fs_1.default.existsSync(p))
+        return {};
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function isAwmEntry(e) {
+    return e.matcher === POST_TOOL_USE_MATCHER &&
+        (e.hooks ?? []).some(h => h.command === AWM_SENSOR_CMD);
+}
+function backupSettings(settingsPath) {
+    if (!fs_1.default.existsSync(settingsPath))
+        return undefined;
+    const awmHome = process.env.AWM_HOME || path_1.default.join(process.env.HOME ?? os_1.default.homedir(), '.awm');
+    const backupDir = path_1.default.join(awmHome, 'backups');
+    fs_1.default.mkdirSync(backupDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '-').slice(0, 19);
+    const backupPath = path_1.default.join(backupDir, `settings.json.${ts}.sensor.bak`);
+    fs_1.default.copyFileSync(settingsPath, backupPath);
+    return backupPath;
+}
+function installSensorHook(settingsPath = defaultSettingsPath()) {
+    const settings = readSettings(settingsPath);
+    const entries = settings?.hooks?.[POST_TOOL_USE_EVENT] ?? [];
+    if (entries.some(isAwmEntry))
+        return { status: 'already-installed' };
+    const backupPath = backupSettings(settingsPath);
+    const newEntry = {
+        matcher: POST_TOOL_USE_MATCHER,
+        hooks: [{ type: 'command', command: AWM_SENSOR_CMD }],
+    };
+    const updated = {
+        ...settings,
+        hooks: {
+            ...(settings.hooks ?? {}),
+            [POST_TOOL_USE_EVENT]: [...entries, newEntry],
+        },
+    };
+    fs_1.default.mkdirSync(path_1.default.dirname(settingsPath), { recursive: true });
+    fs_1.default.writeFileSync(settingsPath, JSON.stringify(updated, null, 2), 'utf-8');
+    return { status: 'installed', backupPath };
+}
+function uninstallSensorHook(settingsPath = defaultSettingsPath()) {
+    if (!fs_1.default.existsSync(settingsPath))
+        return { status: 'not-found' };
+    const settings = readSettings(settingsPath);
+    const entries = settings?.hooks?.[POST_TOOL_USE_EVENT] ?? [];
+    const filtered = entries.filter(e => !isAwmEntry(e));
+    if (filtered.length === entries.length)
+        return { status: 'not-found' };
+    const updated = { ...settings, hooks: { ...(settings.hooks ?? {}), [POST_TOOL_USE_EVENT]: filtered } };
+    if (updated.hooks[POST_TOOL_USE_EVENT].length === 0)
+        delete updated.hooks[POST_TOOL_USE_EVENT];
+    if (Object.keys(updated.hooks).length === 0)
+        delete updated.hooks;
+    fs_1.default.writeFileSync(settingsPath, JSON.stringify(updated, null, 2), 'utf-8');
+    return { status: 'removed' };
+}