@njeybe/nativ 2.0.0

package/dist/core/verifier.js

@@ -0,0 +1,249 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { exec } from 'node:child_process';
+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}` };
+    }
+}
+/**
+ * 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,
+                });
+            }
+        });
+    });
+}
+/**
+ * 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 executeVerification(foundTask.verificationCommand, targetDir, 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;
+    for (const { task, milestone } of candidates) {
+        const vResult = await executeVerification(task.verificationCommand, targetDir, options.timeout);
+        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/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The installed package's version, read from package.json so `nativ --version`, the MCP server info and the
+ * plugin can never disagree with what was published. Works from dist/ (dist/core/version.js -> ../../package.json).
+ */
+export declare function packageVersion(): string;

package/dist/core/version.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+/**
+ * The installed package's version, read from package.json so `nativ --version`, the MCP server info and the
+ * plugin can never disagree with what was published. Works from dist/ (dist/core/version.js -> ../../package.json).
+ */
+export function packageVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+        return typeof pkg.version === 'string' && pkg.version ? pkg.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/core/worktree-merge.d.ts

@@ -0,0 +1,30 @@
+export interface WorktreeMergeOutcome {
+    merged: boolean;
+    /** The agent left uncommitted changes; they were committed on the agent branch before merging. */
+    committedPendingWork: boolean;
+    /** Commit created for the pending work, when there was any. */
+    pendingCommit: string | null;
+    /** The worktree directory and agent branch were removed (only after a successful merge). */
+    cleanedUp: boolean;
+    message: string;
+}
+export declare class WorktreeMergeError extends Error {
+    /** True when the worktree and agent branch were left in place with all work intact. */
+    readonly workPreserved: boolean;
+    constructor(message: string, 
+    /** True when the worktree and agent branch were left in place with all work intact. */
+    workPreserved: boolean);
+}
+/**
+ * Merges `agent/task-<id>` back into the current branch without ever losing agent work:
+ *
+ * 1. Uncommitted changes in the worktree are committed on the agent branch first — the
+ *    verification gatekeeper checked the working tree, so that state is what gets merged.
+ * 2. The branch is merged. On failure (e.g. conflicts) the merge is aborted and the
+ *    worktree and branch are left exactly as they were.
+ * 3. Only after a successful merge is the worktree removed and the (now merged) branch
+ *    deleted with the safe `-d`.
+ *
+ * Git hooks run normally; a failing hook stops the merge with the work preserved.
+ */
+export declare function mergeAgentWorktree(rootDir: string, taskId: string): WorktreeMergeOutcome;

package/dist/core/worktree-merge.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { linkWorktreeAiDirectory, linkWorktreeNodeModules, safeUnlinkWorktreeAiDirectory, safeUnlinkWorktreeNodeModules, } from './root-resolver.js';
+export class WorktreeMergeError extends Error {
+    workPreserved;
+    constructor(message, 
+    /** True when the worktree and agent branch were left in place with all work intact. */
+    workPreserved) {
+        super(message);
+        this.workPreserved = workPreserved;
+        this.name = 'WorktreeMergeError';
+    }
+}
+function git(cwd, args) {
+    const res = spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true, maxBuffer: 64 * 1024 * 1024 });
+    return { ok: res.status === 0, out: `${res.stdout ?? ''}${res.stderr ?? ''}`.trim() };
+}
+function remount(worktreeDir, rootDir) {
+    linkWorktreeAiDirectory(worktreeDir, rootDir);
+    linkWorktreeNodeModules(worktreeDir, rootDir);
+}
+/**
+ * Merges `agent/task-<id>` back into the current branch without ever losing agent work:
+ *
+ * 1. Uncommitted changes in the worktree are committed on the agent branch first — the
+ *    verification gatekeeper checked the working tree, so that state is what gets merged.
+ * 2. The branch is merged. On failure (e.g. conflicts) the merge is aborted and the
+ *    worktree and branch are left exactly as they were.
+ * 3. Only after a successful merge is the worktree removed and the (now merged) branch
+ *    deleted with the safe `-d`.
+ *
+ * Git hooks run normally; a failing hook stops the merge with the work preserved.
+ */
+export function mergeAgentWorktree(rootDir, taskId) {
+    const worktreeDir = path.join(rootDir, '.worktrees', `task-${taskId}`);
+    const branch = `agent/task-${taskId}`;
+    const hasWorktree = fs.existsSync(path.join(worktreeDir, '.git'));
+    if (!git(rootDir, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`]).ok) {
+        throw new WorktreeMergeError(`Branch ${branch} does not exist; nothing to merge.`, false);
+    }
+    let pendingCommit = null;
+    if (hasWorktree) {
+        // The .ai and node_modules junctions must never be staged, even in repos that do not ignore them.
+        safeUnlinkWorktreeNodeModules(worktreeDir);
+        safeUnlinkWorktreeAiDirectory(worktreeDir);
+        const status = git(worktreeDir, ['status', '--porcelain']);
+        if (!status.ok) {
+            remount(worktreeDir, rootDir);
+            throw new WorktreeMergeError(`Could not read the worktree status: ${status.out}`, true);
+        }
+        if (status.out) {
+            const add = git(worktreeDir, ['add', '-A']);
+            const commit = add.ok
+                ? git(worktreeDir, ['commit', '-m', `chore(agent): commit uncommitted work from ${taskId}`, '-m', 'Recorded by nativ before merging the verified worktree.'])
+                : add;
+            if (!commit.ok) {
+                remount(worktreeDir, rootDir);
+                throw new WorktreeMergeError(`Could not commit the agent's uncommitted changes, so nothing was merged or removed: ${commit.out}`, true);
+            }
+            pendingCommit = git(worktreeDir, ['rev-parse', 'HEAD']).out || null;
+        }
+    }
+    const merge = git(rootDir, ['merge', branch, '--no-edit']);
+    if (!merge.ok) {
+        // Leave the main checkout as it was rather than half-merged.
+        if (git(rootDir, ['rev-parse', '--verify', '--quiet', 'MERGE_HEAD']).ok)
+            git(rootDir, ['merge', '--abort']);
+        if (hasWorktree)
+            remount(worktreeDir, rootDir);
+        const conflict = /CONFLICT|Automatic merge failed/i.test(merge.out);
+        throw new WorktreeMergeError(`${conflict ? 'Merge conflict' : 'Merge failed'}; the worktree and ${branch} were kept with all work committed. ${merge.out}`, true);
+    }
+    let cleanedUp = true;
+    if (hasWorktree) {
+        // Everything is committed and merged, so a plain remove succeeds; --force only clears ignored build output.
+        if (!git(rootDir, ['worktree', 'remove', worktreeDir]).ok) {
+            const leftover = git(worktreeDir, ['status', '--porcelain']);
+            if (leftover.ok && !leftover.out)
+                git(rootDir, ['worktree', 'remove', '--force', worktreeDir]);
+        }
+        git(rootDir, ['worktree', 'prune']);
+    }
+    // A directory without git metadata may still hold files nobody committed: report it, never delete it.
+    if (fs.existsSync(worktreeDir))
+        cleanedUp = false;
+    if (!git(rootDir, ['branch', '-d', branch]).ok)
+        cleanedUp = false;
+    return {
+        merged: true,
+        committedPendingWork: pendingCommit !== null,
+        pendingCommit,
+        cleanedUp,
+        message: `Merged ${branch}` +
+            (pendingCommit ? ' (uncommitted agent work was committed first)' : '') +
+            (cleanedUp ? '' : '; the worktree or branch could not be removed and was left in place'),
+    };
+}

package/dist/db/data-engine.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Multi-Engine Live Data Studio Query and Mutation Engine.
+ * Supports PostgreSQL, MySQL, SQLite, MongoDB, and Firebase Firestore.
+ *
+ * Adheres strictly to Zero-Credential Air-Gap rules:
+ * - Direct execution within local process memory.
+ * - Raw credentials and connection URLs are never written to disk or returned in responses.
+ * - Errors are sanitized to remove credentials and passwords before bubbling up.
+ */
+export interface FetchDataOptions {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    order?: 'asc' | 'desc';
+    search?: string;
+}
+export interface FetchDataResult {
+    entity: string;
+    entityType: 'table' | 'collection';
+    primaryKey: string;
+    page: number;
+    limit: number;
+    totalCount: number;
+    totalPages: number;
+    rows: Record<string, unknown>[];
+}
+export interface InsertRecordResult {
+    success: boolean;
+    insertedId: string | number;
+    record: Record<string, unknown>;
+}
+export interface UpdateRecordResult {
+    success: boolean;
+    updatedCount: number;
+    record: Record<string, unknown>;
+}
+export interface DeleteRecordResult {
+    success: boolean;
+    deletedCount: number;
+}
+/** Recursively serializes driver-specific objects (BSON ObjectId, Dates, Buffers, Timestamps) to pure JSON. */
+export declare function serializeValue(val: unknown): unknown;
+export declare function fetchData(url: string, entity: string, options?: FetchDataOptions): Promise<FetchDataResult>;
+export declare function insertRecord(url: string, entity: string, record: Record<string, unknown>): Promise<InsertRecordResult>;
+export declare function updateRecord(url: string, entity: string, primaryKey: string | number, updates: Record<string, unknown>): Promise<UpdateRecordResult>;
+export declare function deleteRecord(url: string, entity: string, primaryKey: string | number): Promise<DeleteRecordResult>;