@njeybe/nativ 2.4.1 → 2.5.1

package/dist/core/tier1-liaison.js

@@ -90,6 +90,62 @@ function loadContracts(root) {
         uiSpecs: read('ui_specs.md') ?? undefined,
     };
 }
+export function loadTriageConfig(root) {
+    const configFile = path.join(root, '.nativ', 'config.json');
+    try {
+        if (!fs.existsSync(configFile))
+            return {};
+        const parsed = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+        if (parsed && typeof parsed === 'object' && parsed.triage) {
+            const res = {};
+            if (typeof parsed.triage.autoTriageEnabled === 'boolean') {
+                res.autoTriageEnabled = parsed.triage.autoTriageEnabled;
+            }
+            if (parsed.triage.riskThreshold === 'safe_contracts_only' || parsed.triage.riskThreshold === 'all_non_destructive') {
+                res.riskThreshold = parsed.triage.riskThreshold;
+            }
+            if (typeof parsed.triage.model === 'string' && parsed.triage.model.trim()) {
+                res.model = parsed.triage.model.trim();
+            }
+            return res;
+        }
+    }
+    catch {
+        // Ignore corrupt or unreadable config file
+    }
+    return {};
+}
+export function saveTriageConfig(root, update) {
+    const nativDir = path.join(root, '.nativ');
+    const configFile = path.join(nativDir, 'config.json');
+    try {
+        if (!fs.existsSync(nativDir))
+            fs.mkdirSync(nativDir, { recursive: true });
+        let existing = {};
+        if (fs.existsSync(configFile)) {
+            try {
+                existing = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+            }
+            catch {
+                existing = {};
+            }
+        }
+        const currentTriage = (existing.triage && typeof existing.triage === 'object') ? existing.triage : {};
+        if (typeof update.autoTriageEnabled === 'boolean')
+            currentTriage.autoTriageEnabled = update.autoTriageEnabled;
+        if (update.riskThreshold)
+            currentTriage.riskThreshold = update.riskThreshold;
+        if (update.model)
+            currentTriage.model = update.model;
+        existing.triage = currentTriage;
+        const tmp = `${configFile}.${process.pid}.${Date.now()}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+        fs.renameSync(tmp, configFile);
+    }
+    catch {
+        // Ignore write failures gracefully
+    }
+}
 /**
  * Tier 1 AI Strategist Liaison instance managing escalation evaluation,
  * auto-patch application, and configuration.
@@ -106,11 +162,12 @@ export class Tier1Liaison {
     constructor(root, options = {}) {
         this.root = root;
         this.options = options;
+        const saved = loadTriageConfig(root);
         this.config = {
             // Off by default: even a fix classified as safe waits for confirmation unless auto-triage is enabled.
-            autoTriageEnabled: options.config?.autoTriageEnabled ?? false,
-            riskThreshold: options.config?.riskThreshold ?? 'safe_contracts_only',
-            model: options.model ?? DEFAULT_MODEL,
+            autoTriageEnabled: options.config?.autoTriageEnabled ?? saved.autoTriageEnabled ?? false,
+            riskThreshold: options.config?.riskThreshold ?? saved.riskThreshold ?? 'safe_contracts_only',
+            model: options.model ?? saved.model ?? DEFAULT_MODEL,
         };
     }
     /** Provider options after the legacy `apiKey` and `model` hints are folded in. */
@@ -155,6 +212,10 @@ export class Tier1Liaison {
         if (body.riskThreshold === 'safe_contracts_only' || body.riskThreshold === 'all_non_destructive') {
             this.config.riskThreshold = body.riskThreshold;
         }
+        if (typeof body.model === 'string' && body.model.trim()) {
+            this.config.model = body.model.trim();
+        }
+        saveTriageConfig(this.root, this.config);
         return { ok: true, config: { ...this.config } };
     }
     async evaluate(escalationId) {

package/dist/core/verifier/executor.d.ts

@@ -0,0 +1,5 @@
+import type { VerificationResult } from './types.js';
+/**
+ * Execute a verification command in the workspace directory with timeout and output capture.
+ */
+export declare function executeVerification(command: string, cwd: string, timeoutMs?: number): Promise<VerificationResult>;

package/dist/core/verifier/executor.js

@@ -0,0 +1,62 @@
+import { exec } from 'node:child_process';
+/**
+ * Execute a verification command in the workspace directory with timeout and output capture.
+ */
+export async function executeVerification(command, cwd, timeoutMs = 120_000) {
+    const trimmed = (command || '').trim();
+    // Treat empty, 'none', or 'skip' as an informational pass
+    if (!trimmed || trimmed.toLowerCase() === 'none' || trimmed.toLowerCase() === 'skip') {
+        return {
+            success: true,
+            exitCode: 0,
+            command: trimmed || 'none',
+            stdout: '',
+            stderr: '',
+            durationMs: 0,
+            skipped: true,
+        };
+    }
+    // Cross-platform compatibility for common test commands on Windows cmd.exe
+    let finalCommand = trimmed;
+    if (process.platform === 'win32') {
+        if (trimmed === 'true')
+            finalCommand = 'exit 0';
+        else if (trimmed === 'false')
+            finalCommand = 'exit 1';
+    }
+    const start = Date.now();
+    return new Promise((resolve) => {
+        exec(finalCommand, {
+            cwd,
+            timeout: timeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+            env: process.env,
+        }, (err, stdout, stderr) => {
+            const durationMs = Date.now() - start;
+            const out = (stdout || '').toString();
+            const errOut = (stderr || '').toString();
+            if (err) {
+                const exitCode = typeof err.code === 'number' ? err.code : 1;
+                resolve({
+                    success: false,
+                    exitCode,
+                    command: trimmed,
+                    stdout: out,
+                    stderr: errOut || err.message,
+                    durationMs,
+                    error: err.killed ? `Command timed out after ${timeoutMs}ms` : err.message,
+                });
+            }
+            else {
+                resolve({
+                    success: true,
+                    exitCode: 0,
+                    command: trimmed,
+                    stdout: out,
+                    stderr: errOut,
+                    durationMs,
+                });
+            }
+        });
+    });
+}

package/dist/core/verifier/phases.d.ts

@@ -0,0 +1,5 @@
+import type { PhasesOutcome, VerifyPhasesConfig } from './types.js';
+/** `verifyPhases` from the main checkout's `.nativ/config.json`, never from a worktree's own copy. */
+export declare function loadVerifyPhases(configDir: string): VerifyPhasesConfig;
+/** Runs the configured phases in order and stops at the first failure. */
+export declare function runVerifyPhases(cwd: string, configDir: string, timeout?: number): Promise<PhasesOutcome>;

package/dist/core/verifier/phases.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseJsonLoose } from '../enforcement.js';
+import { resolveMainRoot } from '../root-resolver.js';
+import { executeVerification } from './executor.js';
+/** Reads the file, retrying once: antivirus or an editor saving can briefly lock it on Windows. */
+function readConfigText(file) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return fs.readFileSync(file, 'utf8');
+        }
+        catch (err) {
+            if (err?.code === 'ENOENT')
+                return null;
+            if (attempt >= 1)
+                throw err;
+        }
+    }
+}
+/** `verifyPhases` from the main checkout's `.nativ/config.json`, never from a worktree's own copy. */
+export function loadVerifyPhases(configDir) {
+    let raw;
+    try {
+        raw = readConfigText(path.join(resolveMainRoot(configDir), '.nativ', 'config.json'));
+    }
+    catch (err) {
+        return { phases: [], error: `.nativ/config.json cannot be read (${err?.message})` };
+    }
+    if (raw === null)
+        return { phases: [] };
+    if (!raw.trim())
+        return { phases: [], error: '.nativ/config.json is empty' };
+    let phases;
+    try {
+        phases = parseJsonLoose(raw)?.verifyPhases;
+    }
+    catch (err) {
+        return { phases: [], error: `.nativ/config.json is not valid JSON (${err?.message})` };
+    }
+    if (phases === undefined || phases === null)
+        return { phases: [] };
+    // An empty or null "run" switches a phase off; a missing or mistyped field is a mistake.
+    const isEntry = (p) => typeof p?.name === 'string' && p.name.trim()
+        && (p.run === null || typeof p.run === 'string');
+    if (!Array.isArray(phases) || !phases.every(isEntry)) {
+        return { phases: [], error: 'verifyPhases must be a list of { "name": "...", "run": "..." } entries' };
+    }
+    const active = phases.filter((p) => p.run && p.run.trim());
+    return { phases: active.map((p) => ({ name: p.name.trim(), run: p.run.trim() })) };
+}
+function configFailure(message) {
+    const error = `${message}, so the configured checks could not run. Fix it and verify again.`;
+    const command = '.nativ/config.json';
+    return { success: false, exitCode: 1, command, stdout: '', stderr: error, durationMs: 0, error };
+}
+/** Runs the configured phases in order and stops at the first failure. */
+export async function runVerifyPhases(cwd, configDir, timeout) {
+    const config = loadVerifyPhases(configDir);
+    if (config.error)
+        return { reports: [], failure: configFailure(config.error) };
+    const reports = [];
+    for (const phase of config.phases) {
+        const res = await executeVerification(phase.run, cwd, timeout);
+        reports.push({ name: phase.name, command: res.command, success: res.success, durationMs: res.durationMs });
+        if (!res.success) {
+            const cause = res.error ? `: ${res.error.trim()}` : '';
+            return { reports, failure: { ...res, phases: reports, error: `Phase "${phase.name}" failed${cause}` } };
+        }
+    }
+    return { reports };
+}

package/dist/core/verifier/task-verifier.d.ts

@@ -0,0 +1,37 @@
+import { MasterPlan, MasterPlanTask } from '../../scanner/types.js';
+import type { BatchVerificationResult, PhasesOutcome, TaskVerificationResult, VerificationResult } from './types.js';
+export declare function loadMasterPlan(targetDir: string): {
+    planPath: string;
+    plan: MasterPlan | null;
+    error?: string;
+};
+/**
+ * Run the code-shape check on a task's target files and print a short summary to stderr.
+ * In 'warn' mode (default) the result is untouched; in 'block' mode issues fail it with a reason.
+ */
+export declare function applyCodeShape(result: VerificationResult, targetDir: string, task: MasterPlanTask): VerificationResult;
+/**
+ * The one verification every path shares: the configured phases in order, stopping at the
+ * first failure, then the task's own command, then the code-shape check.
+ */
+export declare function runTaskVerification(task: MasterPlanTask, options: {
+    cwd: string;
+    configDir?: string;
+    timeout?: number;
+    phases?: PhasesOutcome;
+}): Promise<VerificationResult>;
+/**
+ * Run verification for a single specific task in the plan.
+ */
+export declare function verifyTask(taskId: string, targetDirArg?: string, options?: {
+    timeout?: number;
+}): Promise<TaskVerificationResult>;
+/**
+ * Verify a batch of tasks (by milestone, all completed tasks, or the active in-progress task).
+ */
+export declare function verifyBatch(targetDirArg?: string, options?: {
+    taskId?: string;
+    milestoneId?: string;
+    all?: boolean;
+    timeout?: number;
+}): Promise<BatchVerificationResult>;

package/dist/core/verifier/task-verifier.js

@@ -0,0 +1,233 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { checkCodeShape, formatCodeShapeReport } from '../code-shape.js';
+import { executeVerification } from './executor.js';
+import { runVerifyPhases } from './phases.js';
+export function loadMasterPlan(targetDir) {
+    const planPath = path.join(targetDir, '.ai', 'master_plan.json');
+    if (!fs.existsSync(planPath)) {
+        return { planPath, plan: null, error: `No .ai/master_plan.json found at: ${planPath}` };
+    }
+    try {
+        const raw = fs.readFileSync(planPath, 'utf8');
+        const plan = JSON.parse(raw);
+        return { planPath, plan };
+    }
+    catch (err) {
+        return { planPath, plan: null, error: `Failed to parse .ai/master_plan.json: ${err.message}` };
+    }
+}
+/**
+ * Run the code-shape check on a task's target files and print a short summary to stderr.
+ * In 'warn' mode (default) the result is untouched; in 'block' mode issues fail it with a reason.
+ */
+export function applyCodeShape(result, targetDir, task) {
+    if (result.skipped || !result.success)
+        return result;
+    const report = checkCodeShape(targetDir, task.targetFiles || []);
+    if (report.mode === 'off')
+        return result;
+    result.codeShape = report;
+    const summary = formatCodeShapeReport(report);
+    if (summary)
+        console.error(summary);
+    if (report.mode === 'block' && report.issues.length > 0) {
+        result.success = false;
+        result.exitCode = 1;
+        result.error = `Code shape check failed: ${report.issues.length} issue(s) (codeStyle.mode is "block")`;
+    }
+    return result;
+}
+/**
+ * The one verification every path shares: the configured phases in order, stopping at the
+ * first failure, then the task's own command, then the code-shape check.
+ */
+export async function runTaskVerification(task, options) {
+    const configDir = options.configDir ?? options.cwd;
+    const outcome = options.phases ?? (await runVerifyPhases(options.cwd, configDir, options.timeout));
+    // In a batch the shared phase time is counted once, by the batch, not again for every task.
+    if (outcome.failure) {
+        return { ...outcome.failure, phases: outcome.reports, ...(options.phases ? { durationMs: 0 } : {}) };
+    }
+    const raw = await executeVerification(task.verificationCommand, options.cwd, options.timeout);
+    if (outcome.reports.length) {
+        raw.phases = outcome.reports;
+        raw.durationMs += options.phases ? 0 : outcome.reports.reduce((sum, r) => sum + r.durationMs, 0);
+        raw.skipped = false;
+    }
+    return applyCodeShape(raw, options.cwd, task);
+}
+/**
+ * Run verification for a single specific task in the plan.
+ */
+export async function verifyTask(taskId, targetDirArg, options = {}) {
+    const targetDir = path.resolve(targetDirArg || process.cwd());
+    const { plan, error } = loadMasterPlan(targetDir);
+    if (!plan) {
+        return {
+            taskId,
+            title: 'Unknown',
+            milestoneId: 'unknown',
+            milestoneName: 'Unknown',
+            status: 'unknown',
+            result: {
+                success: false,
+                exitCode: 1,
+                command: '',
+                stdout: '',
+                stderr: error || 'Failed to load master plan',
+                durationMs: 0,
+                error: error || 'Failed to load master plan',
+            },
+        };
+    }
+    let foundTask = null;
+    let foundMilestone = null;
+    for (const m of plan.milestones) {
+        const t = m.tasks.find((item) => item.id === taskId);
+        if (t) {
+            foundTask = t;
+            foundMilestone = m;
+            break;
+        }
+    }
+    if (!foundTask || !foundMilestone) {
+        return {
+            taskId,
+            title: 'Not Found',
+            milestoneId: 'unknown',
+            milestoneName: 'Unknown',
+            status: 'unknown',
+            result: {
+                success: false,
+                exitCode: 1,
+                command: '',
+                stdout: '',
+                stderr: `Task [${taskId}] not found in .ai/master_plan.json`,
+                durationMs: 0,
+                error: `Task [${taskId}] not found`,
+            },
+        };
+    }
+    const result = await runTaskVerification(foundTask, { cwd: targetDir, timeout: options.timeout });
+    return {
+        taskId: foundTask.id,
+        title: foundTask.title,
+        milestoneId: foundMilestone.id,
+        milestoneName: foundMilestone.name,
+        status: foundTask.status,
+        result,
+    };
+}
+/**
+ * Verify a batch of tasks (by milestone, all completed tasks, or the active in-progress task).
+ */
+export async function verifyBatch(targetDirArg, options = {}) {
+    const targetDir = path.resolve(targetDirArg || process.cwd());
+    const { plan, error } = loadMasterPlan(targetDir);
+    if (!plan) {
+        return {
+            projectName: 'unknown',
+            total: 0,
+            passed: 0,
+            failed: 1,
+            skipped: 0,
+            durationMs: 0,
+            tasks: [
+                {
+                    taskId: 'init',
+                    title: 'Plan Loader',
+                    milestoneId: 'unknown',
+                    milestoneName: 'Unknown',
+                    status: 'unknown',
+                    result: {
+                        success: false,
+                        exitCode: 1,
+                        command: '',
+                        stdout: '',
+                        stderr: error || 'Plan not found',
+                        durationMs: 0,
+                        error: error || 'Plan not found',
+                    },
+                },
+            ],
+        };
+    }
+    // Filter tasks to run
+    const candidates = [];
+    for (const m of plan.milestones) {
+        for (const t of m.tasks) {
+            if (options.taskId && t.id === options.taskId) {
+                candidates.push({ task: t, milestone: m });
+            }
+            else if (options.milestoneId && (m.id === options.milestoneId || m.name.toLowerCase() === options.milestoneId.toLowerCase())) {
+                candidates.push({ task: t, milestone: m });
+            }
+            else if (options.all) {
+                // All tasks with verification commands (prefer completed or in_progress, but include all)
+                candidates.push({ task: t, milestone: m });
+            }
+        }
+    }
+    // If no filters specified, find the current in_progress task, or next ready task
+    if (!options.taskId && !options.milestoneId && !options.all) {
+        let activeTask = null;
+        for (const m of plan.milestones) {
+            const inProgress = m.tasks.find((t) => t.status === 'in_progress');
+            if (inProgress) {
+                activeTask = { task: inProgress, milestone: m };
+                break;
+            }
+        }
+        if (!activeTask) {
+            for (const m of plan.milestones) {
+                const pending = m.tasks.find((t) => t.status === 'pending');
+                if (pending) {
+                    activeTask = { task: pending, milestone: m };
+                    break;
+                }
+            }
+        }
+        if (activeTask) {
+            candidates.push(activeTask);
+        }
+    }
+    const results = [];
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let totalDuration = 0;
+    // The phases check the whole project, so one run serves every task in the batch.
+    const phases = candidates.length ? await runVerifyPhases(targetDir, targetDir, options.timeout) : { reports: [] };
+    totalDuration += phases.reports.reduce((sum, r) => sum + r.durationMs, 0);
+    for (const { task, milestone } of candidates) {
+        const vResult = await runTaskVerification(task, { cwd: targetDir, timeout: options.timeout, phases });
+        totalDuration += vResult.durationMs;
+        if (vResult.skipped) {
+            skipped++;
+        }
+        else if (vResult.success) {
+            passed++;
+        }
+        else {
+            failed++;
+        }
+        results.push({
+            taskId: task.id,
+            title: task.title,
+            milestoneId: milestone.id,
+            milestoneName: milestone.name,
+            status: task.status,
+            result: vResult,
+        });
+    }
+    return {
+        projectName: plan.projectName,
+        total: candidates.length,
+        passed,
+        failed,
+        skipped,
+        durationMs: totalDuration,
+        tasks: results,
+    };
+}

package/dist/core/verifier/types.d.ts

@@ -0,0 +1,51 @@
+import type { CodeShapeReport } from '../code-shape.js';
+export interface VerificationResult {
+    success: boolean;
+    exitCode: number;
+    command: string;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    error?: string;
+    skipped?: boolean;
+    codeShape?: CodeShapeReport;
+    /** Results of the configured `verifyPhases`, when any ran. */
+    phases?: PhaseResult[];
+}
+export interface PhaseResult {
+    name: string;
+    command: string;
+    success: boolean;
+    durationMs: number;
+}
+export interface TaskVerificationResult {
+    taskId: string;
+    title: string;
+    milestoneId: string;
+    milestoneName: string;
+    status: string;
+    result: VerificationResult;
+}
+export interface BatchVerificationResult {
+    projectName: string;
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    durationMs: number;
+    tasks: TaskVerificationResult[];
+}
+export interface VerifyPhase {
+    name: string;
+    run: string;
+}
+/** Configured phases, or an error when the config exists but cannot be trusted to say what they are. */
+export interface VerifyPhasesConfig {
+    phases: VerifyPhase[];
+    error?: string;
+}
+/** Outcome of running the configured phases once; shared by every task in a batch. */
+export interface PhasesOutcome {
+    reports: PhaseResult[];
+    failure?: VerificationResult;
+}

package/dist/core/verifier/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/verifier.d.ts

@@ -1,95 +1,7 @@
-import { MasterPlan, MasterPlanTask } from '../scanner/types.js';
-import { type CodeShapeReport } from './code-shape.js';
-export interface VerificationResult {
-    success: boolean;
-    exitCode: number;
-    command: string;
-    stdout: string;
-    stderr: string;
-    durationMs: number;
-    error?: string;
-    skipped?: boolean;
-    codeShape?: CodeShapeReport;
-    /** Results of the configured `verifyPhases`, when any ran. */
-    phases?: PhaseResult[];
-}
-export interface PhaseResult {
-    name: string;
-    command: string;
-    success: boolean;
-    durationMs: number;
-}
-export interface TaskVerificationResult {
-    taskId: string;
-    title: string;
-    milestoneId: string;
-    milestoneName: string;
-    status: string;
-    result: VerificationResult;
-}
-export interface BatchVerificationResult {
-    projectName: string;
-    total: number;
-    passed: number;
-    failed: number;
-    skipped: number;
-    durationMs: number;
-    tasks: TaskVerificationResult[];
-}
-export declare function loadMasterPlan(targetDir: string): {
-    planPath: string;
-    plan: MasterPlan | null;
-    error?: string;
-};
 /**
- * Execute a verification command in the workspace directory with timeout and output capture.
+ * Re-exports the modular verifier engine components.
  */
-export declare function executeVerification(command: string, cwd: string, timeoutMs?: number): Promise<VerificationResult>;
-/**
- * Run the code-shape check on a task's target files and print a short summary to stderr.
- * In 'warn' mode (default) the result is untouched; in 'block' mode issues fail it with a reason.
- */
-export declare function applyCodeShape(result: VerificationResult, targetDir: string, task: MasterPlanTask): VerificationResult;
-export interface VerifyPhase {
-    name: string;
-    run: string;
-}
-/** Configured phases, or an error when the config exists but cannot be trusted to say what they are. */
-export interface VerifyPhasesConfig {
-    phases: VerifyPhase[];
-    error?: string;
-}
-/** `verifyPhases` from the main checkout's `.nativ/config.json`, never from a worktree's own copy. */
-export declare function loadVerifyPhases(configDir: string): VerifyPhasesConfig;
-/** Outcome of running the configured phases once; shared by every task in a batch. */
-export interface PhasesOutcome {
-    reports: PhaseResult[];
-    failure?: VerificationResult;
-}
-/** Runs the configured phases in order and stops at the first failure. */
-export declare function runVerifyPhases(cwd: string, configDir: string, timeout?: number): Promise<PhasesOutcome>;
-/**
- * The one verification every path shares: the configured phases in order, stopping at the
- * first failure, then the task's own command, then the code-shape check.
- */
-export declare function runTaskVerification(task: MasterPlanTask, options: {
-    cwd: string;
-    configDir?: string;
-    timeout?: number;
-    phases?: PhasesOutcome;
-}): Promise<VerificationResult>;
-/**
- * Run verification for a single specific task in the plan.
- */
-export declare function verifyTask(taskId: string, targetDirArg?: string, options?: {
-    timeout?: number;
-}): Promise<TaskVerificationResult>;
-/**
- * Verify a batch of tasks (by milestone, all completed tasks, or the active in-progress task).
- */
-export declare function verifyBatch(targetDirArg?: string, options?: {
-    taskId?: string;
-    milestoneId?: string;
-    all?: boolean;
-    timeout?: number;
-}): Promise<BatchVerificationResult>;
+export * from './verifier/types.js';
+export { executeVerification } from './verifier/executor.js';
+export { loadVerifyPhases, runVerifyPhases } from './verifier/phases.js';
+export { loadMasterPlan, applyCodeShape, runTaskVerification, verifyTask, verifyBatch, } from './verifier/task-verifier.js';