@claude-flow/cli 3.32.2 → 3.32.3

package/dist/src/services/weight-eft.js

@@ -1,296 +0,0 @@
-/**
- * weight-eft.ts — Optional-dependency service wrapper around
- * `@metaharness/weight-eft` (agenticow / ADR-150 weight-eft slice).
- *
- * WHAT THIS SHIPS (and what it deliberately does NOT)
- * ---------------------------------------------------
- * This service turns ruflo's captured run transcripts into AUDITED TRAINING
- * DATA + a COST-PARETO measurement + a GPU TRAINING PLAN. It does NOT train a
- * model and it does NOT "reduce escalation":
- *   - `runExport`  → SFT (OpenAI chat) + DPO (TRL preference) JSONL + a guard
- *                    report (contamination / reward-hack / long-context). $0.
- *   - `runPlan`    → the GPU training plan + the exact `ruvllm microlora`
- *                    command a GPU host would run. $0 dry-run — never spawns.
- *   - `runEval`    → the cost-Pareto delta folded from two CascadeOutcome[]. $0.
- *   - `runRemoteTrain` → an SSH-based remote-GPU invocation. DRY-RUN by default
- *                    (prints commands + read-only preflight); real compute only
- *                    behind explicit `execute && yes`. This is the ONLY path
- *                    that can spend, and it spends on the USER's host, not $0.
- *
- * HARD HONESTY RULE (do not overclaim): weight-eft's own `train` never spawns
- * (its README §Status), and no GPU tune has run here. `resolved` in the
- * captured archive is a PROXY (ruflo has no SWE-bench gold oracle) — the SFT
- * data-quality caveat stands. Nothing here claims ruflo "trains a model" as a
- * $0/local capability.
- *
- * ADR-150 GRACEFUL DEGRADATION
- * ----------------------------
- * `@metaharness/weight-eft` is an OPTIONAL dependency. Every entry point loads
- * it via a dynamic import through `loadWeightEft()` and returns a structured
- * `{ degraded: true }` result when it is absent — never a throw. There is NO
- * static `import … from '@metaharness/weight-eft'` anywhere in this file; the
- * types below are LOCAL mirrors so tsc stays green with the package removed.
- *
- * @module services/weight-eft
- */
-import { spawnSync } from 'node:child_process';
-const WEIGHT_EFT_PKG = '@metaharness/weight-eft';
-/**
- * Load `@metaharness/weight-eft` (optional dep). Returns the module or `null`
- * when it is absent/broken. Never throws. The specifier is held in a variable
- * so tsc does not statically resolve the package (keeps the build green when
- * the optional dep is removed — ADR-150).
- */
-export async function loadWeightEft(importer) {
-    const load = importer ?? (() => import(/* @vite-ignore */ WEIGHT_EFT_PKG));
-    try {
-        const mod = (await load());
-        const api = (mod && typeof mod.exportTrainingData === 'function' ? mod : mod?.default);
-        if (!api || typeof api.exportTrainingData !== 'function')
-            return null;
-        return api;
-    }
-    catch {
-        return null; // MODULE_NOT_FOUND or any load error → degraded
-    }
-}
-/**
- * Map captured ruflo run transcripts to the DarwinTrajectory[] contract the
- * weight-eft exporter codes against. PURE + synchronous — this is the seam the
- * archive-builder unit test exercises.
- *
- * A record is skipped (not thrown) when it lacks the minimum an exporter needs:
- * an instance_id and a non-empty messages array. `resolved` is copied verbatim
- * and its proxy provenance is tallied so the caller can print an honest note.
- */
-export function buildArchiveFromRecords(records) {
-    const trajectories = [];
-    const stats = {
-        total: 0, resolved: 0, byTier: { cheap: 0, frontier: 0 }, byResolvedSource: {}, skipped: 0,
-    };
-    let hasGold = false;
-    for (const r of records) {
-        if (!r || !r.instance_id || !Array.isArray(r.messages) || r.messages.length === 0) {
-            stats.skipped++;
-            continue;
-        }
-        const tier = r.tier === 'cheap' ? 'cheap' : 'frontier';
-        trajectories.push({
-            instance_id: r.instance_id,
-            model: r.model,
-            tier,
-            resolved: !!r.resolved,
-            messages: r.messages,
-            model_patch: r.model_patch ?? '',
-            sample: r.sample ?? 0,
-            ...(r.source ? { source: r.source } : {}),
-        });
-        stats.total++;
-        stats.byTier[tier]++;
-        if (r.resolved)
-            stats.resolved++;
-        const src = r.resolved_source ?? 'external';
-        stats.byResolvedSource[src] = (stats.byResolvedSource[src] ?? 0) + 1;
-        if (src === 'gold-oracle')
-            hasGold = true;
-    }
-    const proxyNote = hasGold
-        ? 'resolved: some records carry gold-oracle status; others are proxies (see byResolvedSource).'
-        : 'resolved is a PROXY — ruflo has no SWE-bench gold oracle. `output-verifier`/`api-success` ' +
-            'labels are explicitly-marked proxies, NOT conformant gold eval. SFT/DPO quality is bounded by this.';
-    return { trajectories, stats, proxyNote };
-}
-/** Run the weight-eft exporter over a DarwinTrajectory[] archive. $0. */
-export async function runExport(opts) {
-    const api = await loadWeightEft(opts.importer);
-    if (!api)
-        return { degraded: true, reason: 'weight-eft-not-available' };
-    try {
-        const res = api.exportTrainingData(opts.archive, {
-            evalHoldout: opts.evalHoldout ?? [],
-            ...(opts.maxTokens != null ? { maxTokens: opts.maxTokens } : {}),
-            ...(opts.truncateOverLength != null ? { truncateOverLength: opts.truncateOverLength } : {}),
-            // reward-hack filter defaults ON inside weight-eft; only forward an explicit override
-            ...(opts.dropRewardHacked != null ? { dropRewardHacked: opts.dropRewardHacked } : {}),
-        });
-        return {
-            degraded: false,
-            report: res.report,
-            sftJsonl: api.sftToJsonl(res.sft),
-            dpoJsonl: api.dpoToJsonl(res.dpo),
-            sftRows: res.sft.length,
-            dpoRows: res.dpo.length,
-        };
-    }
-    catch (e) {
-        // exportTrainingData throws on contamination-guard violation — surface it.
-        return { degraded: true, reason: `export-failed: ${e.message}` };
-    }
-}
-/** Emit the two-stage (SFT → on-policy DPO) GPU training plan. $0 dry-run. */
-export async function runPlan(opts) {
-    const api = await loadWeightEft(opts.importer);
-    if (!api)
-        return { degraded: true, reason: 'weight-eft-not-available' };
-    const base = opts.base ?? DEFAULT_BASE_MODEL;
-    try {
-        const plan = api.twoStagePlan(base, opts.sftPath, opts.dpoPath, opts.adapterPrefix ?? 'ruflo-weft');
-        return { degraded: false, base, sft: plan.sft, dpo: plan.dpo };
-    }
-    catch (e) {
-        return { degraded: true, reason: `plan-failed: ${e.message}` };
-    }
-}
-/** Fold base + adapter CascadeOutcome[] into the cost-Pareto delta. $0. */
-export async function runEval(opts) {
-    const api = await loadWeightEft(opts.importer);
-    if (!api)
-        return { degraded: true, reason: 'weight-eft-not-available' };
-    try {
-        return { degraded: false, delta: api.costParetoDelta(opts.baseOutcomes, opts.adapterOutcomes) };
-    }
-    catch (e) {
-        return { degraded: true, reason: `eval-failed: ${e.message}` };
-    }
-}
-/** Default cheap-tier tune target — a 7B coder in the tunable [1,14]B band. */
-export const DEFAULT_BASE_MODEL = { id: 'Qwen/Qwen2.5-Coder-7B-Instruct', paramsB: 7 };
-function sshTarget(args) {
-    return args.sshUser ? `${args.sshUser}@${args.host}` : args.host;
-}
-function sshBase(port) {
-    return ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=8', '-p', String(port)];
-}
-/** Render an argv as a copy-pasteable shell line (quoting args with spaces). */
-function renderCmd(argv) {
-    return argv.map((a) => (/[\s"'$]/.test(a) ? `'${a.replace(/'/g, `'\\''`)}'` : a)).join(' ');
-}
-/**
- * Construct the exact ssh/rsync/ruvllm invocations a remote GPU tune would run.
- * PURE — no spawning, no filesystem, deterministic. This is the seam the
- * command-construction unit test exercises. The ruvllm commands mirror the
- * canonical `ruvllm microlora sft … && ruvllm microlora dpo --init-from …`
- * plan weight-eft emits, wrapped for SSH execution on the remote host.
- */
-export function buildRemoteTrainInvocation(args) {
-    const base = args.base ?? DEFAULT_BASE_MODEL.id;
-    const port = args.sshPort ?? 22;
-    const runId = args.runId ?? `weft-${Date.now().toString(36)}`;
-    const prefix = args.adapterPrefix ?? 'ruflo-weft';
-    const remoteWorkdir = args.remoteWorkdir ?? `~/.ruflo-weft/${runId}`;
-    const adapterDir = args.adapterDir ?? '.claude-flow/neural';
-    const target = sshTarget(args);
-    const ssh = sshBase(port);
-    const rsyncSsh = `ssh -p ${port}`;
-    const sftAdapter = `${prefix}-${runId}-sft`;
-    const dpoAdapter = `${prefix}-${runId}-dpo`;
-    const preflight = [
-        { label: 'ssh reachability', argv: ['ssh', ...ssh, target, 'true'] },
-        { label: 'ruvllm version', argv: ['ssh', ...ssh, target, 'ruvllm --version || echo RUVLLM_MISSING'] },
-        { label: 'gpu probe', argv: ['ssh', ...ssh, target, 'nvidia-smi -L || echo NO_NVIDIA_SMI'] },
-    ];
-    const sftCmd = `cd ${remoteWorkdir} && ruvllm microlora sft --base ${base} --data sft.jsonl --output ${sftAdapter}`;
-    const dpoCmd = `cd ${remoteWorkdir} && ruvllm microlora dpo --base ${base} --init-from ${sftAdapter} ` +
-        `--data dpo.jsonl --output ${dpoAdapter}`;
-    const steps = [
-        { label: 'remote mkdir', argv: ['ssh', ...ssh, target, `mkdir -p ${remoteWorkdir}`] },
-        { label: 'rsync sft up', argv: ['rsync', '-az', '-e', rsyncSsh, args.sftPath, `${target}:${remoteWorkdir}/sft.jsonl`] },
-        { label: 'rsync dpo up', argv: ['rsync', '-az', '-e', rsyncSsh, args.dpoPath, `${target}:${remoteWorkdir}/dpo.jsonl`] },
-        { label: 'ruvllm sft (real GPU compute)', argv: ['ssh', ...ssh, target, sftCmd] },
-        { label: 'ruvllm dpo (real GPU compute)', argv: ['ssh', ...ssh, target, dpoCmd] },
-        { label: 'rsync adapter back', argv: ['rsync', '-az', '-e', rsyncSsh, `${target}:${remoteWorkdir}/${dpoAdapter}/`, `${adapterDir}/${dpoAdapter}/`] },
-    ];
-    return {
-        host: args.host, base, runId, remoteWorkdir, adapterDir, sftAdapter, dpoAdapter,
-        preflight, steps,
-        humanCommands: [...preflight, ...steps].map((s) => renderCmd(s.argv)),
-    };
-}
-/**
- * Run (or, by default, DRY-RUN) a remote-GPU tune. SAFETY MODEL:
- *   - DEFAULT (no execute): builds the plan, runs read-only preflight probes,
- *     and returns the commands that WOULD run. NO rsync of data, NO training.
- *   - execute && !yes → 'refused' (real GPU spend needs an explicit second gate).
- *   - execute && yes  → runs preflight; if unreachable → 'preflight-failed'
- *     WITHOUT training; else runs rsync + ssh ruvllm sft/dpo + fetch-back.
- *   - No `ssh` binary / host unreachable / any spawn error → structured
- *     degraded/preflight-failed. NEVER throws.
- *
- * `spawn` is injected for testing so CI never touches a live host.
- */
-export async function runRemoteTrain(args) {
-    let plan;
-    try {
-        plan = buildRemoteTrainInvocation(args);
-    }
-    catch (e) {
-        return { degraded: true, reason: `plan-construction-failed: ${e.message}` };
-    }
-    const spawn = args.spawn ?? defaultSpawn;
-    // Preflight — read-only reachability/capability probes. These DO contact the
-    // remote host (ssh ... true), so a bare dry-run must NOT run them: "no
-    // implicit remote execution" (adversarial RC finding). Probes run only when
-    // executing, or when the caller explicitly opts in with --preflight.
-    const runProbe = (s) => {
-        try {
-            const r = spawn(s.argv[0], s.argv.slice(1));
-            if (r.error)
-                return { label: s.label, ok: false, detail: r.error.message };
-            const out = `${r.stdout ?? ''}${r.stderr ?? ''}`.trim();
-            const ok = (r.status ?? 1) === 0 && !/RUVLLM_MISSING|NO_NVIDIA_SMI/.test(out);
-            return { label: s.label, ok, detail: out.slice(0, 200) || `exit ${r.status ?? 'null'}` };
-        }
-        catch (e) {
-            return { label: s.label, ok: false, detail: e.message };
-        }
-    };
-    const doProbe = args.execute === true || args.preflight === true;
-    const preflight = doProbe ? plan.preflight.map(runProbe) : [];
-    const reachable = preflight[0]?.ok === true;
-    if (!args.execute) {
-        // Bare dry-run is fully offline — plan + commands only, no host contact.
-        return {
-            degraded: false, mode: 'dry-run', plan, preflight,
-            reason: doProbe ? undefined : 'offline dry-run — no host contacted. Add --preflight to probe reachability/GPU, or --execute --yes to train.',
-        };
-    }
-    if (!args.yes) {
-        return {
-            degraded: false, mode: 'refused', plan, preflight,
-            reason: '--execute runs REAL GPU compute on your host; re-run with --yes to confirm the spend.',
-        };
-    }
-    if (!reachable) {
-        return { degraded: false, mode: 'preflight-failed', plan, preflight, reason: 'ssh host not reachable — aborting before any data transfer or training.' };
-    }
-    // Execute the mutating steps sequentially, stopping at the first failure.
-    const steps = [];
-    for (const s of plan.steps) {
-        let entry;
-        try {
-            const r = spawn(s.argv[0], s.argv.slice(1));
-            const out = `${r.stdout ?? ''}${r.stderr ?? ''}`.trim();
-            entry = { label: s.label, ok: !r.error && (r.status ?? 1) === 0, detail: r.error ? r.error.message : (out.slice(0, 200) || `exit ${r.status ?? 'null'}`) };
-        }
-        catch (e) {
-            entry = { label: s.label, ok: false, detail: e.message };
-        }
-        steps.push(entry);
-        if (!entry.ok)
-            break;
-    }
-    return { degraded: false, mode: 'executed', plan, preflight, steps };
-}
-/** Default spawn — synchronous child_process, imported lazily so this module
- *  stays importable in any environment. Never throws (spawnSync surfaces
- *  errors on the returned object). */
-function defaultSpawn(cmd, argv) {
-    try {
-        const r = spawnSync(cmd, argv, { encoding: 'utf8', timeout: 30 * 60 * 1000 });
-        return { status: r.status, stdout: r.stdout, stderr: r.stderr, error: r.error ?? undefined };
-    }
-    catch (e) {
-        return { status: null, error: e };
-    }
-}
-//# sourceMappingURL=weight-eft.js.map