sneakoscope 7.0.2 → 7.0.5

package/dist/core/providers/glm/naruto/glm-naruto-worktree-manager.js

@@ -1,71 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { ensureDir } from '../../../fsx.js';
-export async function getGitRoot(cwd) {
-    const result = await runGit(cwd, ['rev-parse', '--show-toplevel']);
-    return result.code === 0 ? result.stdout.trim() || null : null;
-}
-export async function getGitHead(cwd) {
-    const result = await runGit(cwd, ['rev-parse', 'HEAD']);
-    return result.code === 0 ? result.stdout.trim() || null : null;
-}
-export async function createGlmNarutoWorkerWorktree(input) {
-    const baseCommit = input.baseCommit || await getGitHead(input.repoRoot) || 'HEAD';
-    const safeMission = input.missionId.replace(/[^A-Za-z0-9._:-]/g, '-');
-    const root = path.join(input.repoRoot, '.sneakoscope', 'glm-naruto', safeMission, 'worktrees');
-    await ensureDir(root);
-    const safeWorker = input.workerId.replace(/[^A-Za-z0-9._:-]/g, '-');
-    const worktreePath = path.join(root, safeWorker);
-    const branch = `sks/glm-naruto/${safeMission}/${safeWorker}`.slice(0, 240);
-    const result = await runGit(input.repoRoot, ['worktree', 'add', '-f', '-b', branch, worktreePath, baseCommit]);
-    if (result.code !== 0) {
-        throw new Error(result.stderr || result.stdout || 'git worktree add failed');
-    }
-    return { worker_id: input.workerId, path: worktreePath, branch, base_commit: baseCommit };
-}
-export async function applyPatchInWorktree(worktreePath, patch) {
-    const checked = await runGit(worktreePath, ['apply', '--check', '--whitespace=nowarn', '-'], patch);
-    if (checked.code !== 0)
-        return { ok: false, stderr: checked.stderr || checked.stdout };
-    const applied = await runGit(worktreePath, ['apply', '--whitespace=nowarn', '-'], patch);
-    return { ok: applied.code === 0, stderr: applied.stderr || applied.stdout };
-}
-export async function diffWorktree(worktreePath) {
-    const result = await runGit(worktreePath, ['diff', 'HEAD']);
-    return result.stdout;
-}
-export async function removeGlmNarutoWorkerWorktree(repoRoot, lease) {
-    const removed = await runGit(repoRoot, ['worktree', 'remove', '--force', lease.path]);
-    const deleted = await runGit(repoRoot, ['branch', '-D', lease.branch]);
-    if (removed.code !== 0)
-        return { ok: false, error: removed.stderr || removed.stdout };
-    if (deleted.code !== 0)
-        return { ok: false, error: deleted.stderr || deleted.stdout };
-    return { ok: true };
-}
-function runGit(cwd, args, input) {
-    return new Promise((resolve) => {
-        const child = spawn('git', [...args], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
-        let stdout = '';
-        let stderr = '';
-        let settled = false;
-        const finish = (code) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve({ code, stdout, stderr });
-        };
-        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
-        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
-        child.stdin.on('error', (error) => {
-            if (error.code !== 'EPIPE')
-                stderr += `${stderr ? '\n' : ''}${error.message}`;
-        });
-        child.on('error', (error) => {
-            stderr += `${stderr ? '\n' : ''}${error.message}`;
-            finish(null);
-        });
-        child.on('close', finish);
-        child.stdin.end(input || '');
-    });
-}

package/dist/core/providers/glm/naruto/glm-naruto-worktree-worker.js

@@ -1,73 +0,0 @@
-import { createPatchEnvelope } from './glm-naruto-patch-envelope.js';
-import { sha256 } from '../../../fsx.js';
-import { parseGlmNarutoPatchCandidate } from './glm-naruto-patch-candidate-parser.js';
-import { applyPatchInWorktree, createGlmNarutoWorkerWorktree, diffWorktree } from './glm-naruto-worktree-manager.js';
-import { cleanupGlmNarutoWorktree } from './glm-naruto-worktree-cleanup.js';
-export async function materializePatchViaWorktree(input) {
-    let lease;
-    try {
-        lease = await createGlmNarutoWorkerWorktree({
-            repoRoot: input.repoRoot,
-            missionId: input.missionId,
-            workerId: input.envelope.worker_id,
-            ...(input.baseCommit !== undefined ? { baseCommit: input.baseCommit } : {})
-        });
-        const parsed = parseGlmNarutoPatchCandidate(input.envelope.patch);
-        const parseProof = {
-            candidate_body_sha256: sha256(input.envelope.patch),
-            extracted_patch_sha256: parsed.ok ? sha256(parsed.patch) : null,
-            applied_patch_was_extracted: false
-        };
-        if (!parsed.ok) {
-            await cleanupGlmNarutoWorktree({ repoRoot: input.repoRoot, missionId: input.missionId, lease, cleanup: input.cleanup });
-            return {
-                ok: false,
-                envelope: { ...input.envelope, status: 'gate_failed', blockers: parsed.blockers },
-                lease,
-                blockers: parsed.blockers,
-                worktree: parseProof
-            };
-        }
-        const applied = await applyPatchInWorktree(lease.path, parsed.patch);
-        if (!applied.ok) {
-            await cleanupGlmNarutoWorktree({ repoRoot: input.repoRoot, missionId: input.missionId, lease, cleanup: input.cleanup });
-            return {
-                ok: false,
-                envelope: { ...input.envelope, status: 'gate_failed', blockers: ['worktree_patch_apply_failed'] },
-                lease,
-                blockers: ['worktree_patch_apply_failed'],
-                worktree: { ...parseProof, applied_patch_was_extracted: true }
-            };
-        }
-        const diff = await diffWorktree(lease.path);
-        const envelope = createPatchEnvelope({
-            missionId: input.envelope.mission_id,
-            workerId: input.envelope.worker_id,
-            shardId: input.envelope.shard_id,
-            baseDigest: input.envelope.base_digest,
-            patch: diff || parsed.patch,
-            strategy: input.envelope.strategy,
-            reasoningEffort: input.envelope.reasoning_effort,
-            status: input.envelope.status,
-            warnings: [...input.envelope.warnings, `worktree:${lease.path}`]
-        });
-        await cleanupGlmNarutoWorktree({ repoRoot: input.repoRoot, missionId: input.missionId, lease, cleanup: input.cleanup });
-        return {
-            ok: true,
-            envelope,
-            lease,
-            blockers: [],
-            worktree: { ...parseProof, applied_patch_was_extracted: true }
-        };
-    }
-    catch (err) {
-        if (lease)
-            await cleanupGlmNarutoWorktree({ repoRoot: input.repoRoot, missionId: input.missionId, lease, cleanup: input.cleanup });
-        return {
-            ok: false,
-            envelope: { ...input.envelope, status: 'gate_failed', blockers: ['glm_naruto_worktree_not_implemented_or_unavailable'] },
-            ...(lease ? { lease } : {}),
-            blockers: ['glm_naruto_worktree_not_implemented_or_unavailable', err instanceof Error ? err.message : String(err)]
-        };
-    }
-}

package/dist/core/providers/glm/naruto/glm-naruto-worktree.js

@@ -1,62 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-export async function createWorktree(repoRoot, missionId, workerId, baseCommit) {
-    const branch = `sks-glm-naruto/${missionId}/${workerId}`;
-    const worktreePath = path.join(repoRoot, '.sneakoscope', 'glm-naruto', 'worktrees', missionId, workerId);
-    await runGit(repoRoot, ['worktree', 'add', '-b', branch, worktreePath, baseCommit || 'HEAD']);
-    return { path: worktreePath, workerId, branch };
-}
-export async function removeWorktree(repoRoot, worktree) {
-    try {
-        await runGit(repoRoot, ['worktree', 'remove', '--force', worktree.path]);
-        await runGit(repoRoot, ['branch', '-D', worktree.branch]);
-    }
-    catch {
-        // best-effort cleanup
-    }
-}
-export async function applyPatchToWorktree(worktreePath, patch) {
-    try {
-        const result = await runGit(worktreePath, ['apply', '--whitespace=nowarn', '-'], patch);
-        return { ok: result.code === 0, stderr: result.stderr };
-    }
-    catch (err) {
-        return { ok: false, stderr: String(err) };
-    }
-}
-export async function getWorktreeDiff(worktreePath) {
-    const result = await runGit(worktreePath, ['diff', 'HEAD']);
-    return result.stdout;
-}
-export async function resetWorktree(worktreePath) {
-    await runGit(worktreePath, ['checkout', '--', '.']);
-}
-function runGit(cwd, args, stdin) {
-    return new Promise((resolve) => {
-        const child = spawn('git', [...args], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
-        let stdout = '';
-        let stderr = '';
-        let settled = false;
-        const finish = (code) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve({ code, stdout, stderr });
-        };
-        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
-        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
-        child.stdin.on('error', (error) => {
-            if (error.code !== 'EPIPE')
-                stderr += `${stderr ? '\n' : ''}${error.message}`;
-        });
-        child.on('error', (error) => {
-            stderr += `${stderr ? '\n' : ''}${error.message}`;
-            finish(null);
-        });
-        child.on('close', finish);
-        if (stdin !== undefined)
-            child.stdin.end(stdin);
-        else
-            child.stdin.end();
-    });
-}