@cjhyy/code-shell-core 0.7.0 → 0.8.0

package/dist/arena/strategies/utils.js

@@ -1,603 +0,0 @@
-/** Shared utilities for arena strategy implementations. */
-import { logger } from "../../logging/logger.js";
-/** Coerce a value to string — handles cases where LLM returns number/object instead of string */
-function asString(v) {
-    if (typeof v === "string")
-        return v;
-    if (v == null)
-        return "";
-    if (typeof v === "number" || typeof v === "boolean")
-        return String(v);
-    return "";
-}
-/**
- * Sanitize LLM-originated text before re-injecting into a prompt.
- * Strips patterns that could be interpreted as prompt-level instructions.
- */
-function sanitizeForPrompt(text) {
-    if (!text)
-        return "";
-    return text
-        .replace(/<\/?(?:system|assistant|user|system-reminder)[^>]*>/gi, "")
-        .replace(/^(?:IGNORE|DISREGARD|FORGET|OVERRIDE|SYSTEM|INSTRUCTION)[:\s].*/gim, "")
-        .slice(0, 3000);
-}
-// extractJSON / extractJSONArray are generic JSON extractors with no Arena
-// dependency. They moved to utils/json.ts so non-Arena consumers (e.g.
-// services/memory-orchestrator) can use them without importing this Arena
-// module — that import made Arena a dependency of a core service. Re-exported
-// here for back-compat with Arena's own callers and the existing test.
-export { extractJSON, extractJSONArray } from "../../utils/json.js";
-import { extractJSON, extractJSONArray } from "../../utils/json.js";
-/** Format base context into a readable text block for LLM prompts */
-export function formatBaseContext(ctx) {
-    const sections = [];
-    // Quick facts
-    if (ctx.quickFacts.length > 0) {
-        sections.push(`## Quick Facts\n${ctx.quickFacts.map((f) => `- ${f.label}: ${f.value}`).join("\n")}`);
-    }
-    // Artifacts
-    for (const artifact of ctx.artifacts) {
-        const header = artifact.ref ? `${artifact.title} (${artifact.ref})` : artifact.title;
-        sections.push(`## ${artifact.kind.toUpperCase()}: ${header}\n\`\`\`\n${artifact.preview}\n\`\`\``);
-    }
-    return sections.join("\n\n");
-}
-/** Format participant reports for cross-review or consensus prompts */
-export function formatReports(reports) {
-    return reports.map((r) => {
-        const findingsList = r.findings.map((f) => `  - [${f.id}] (${f.kind}${f.severity ? `, ${f.severity}` : ""}) ${f.title}\n` +
-            `    ${f.summary}\n` +
-            `    Evidence: ${f.evidence.map((e) => `${e.type}:${e.ref}`).join(", ")}\n` +
-            `    Confidence: ${f.confidence}` +
-            (f.suggestedChange ? `\n    Suggested: ${f.suggestedChange}` : "")).join("\n");
-        return `### ${r.participant}\n${r.contextSummary}\n\nFindings:\n${findingsList}`;
-    }).join("\n\n");
-}
-/** Format finding reviews for consensus prompts */
-export function formatFindingReviews(reviews) {
-    if (reviews.length === 0)
-        return "No peer reviews.";
-    return reviews.map((r) => `[${r.reviewer}] on ${r.findingId}: ${r.verdict}${r.reason ? ` — ${r.reason}` : ""}`).join("\n");
-}
-/**
- * Parse a ParticipantReport. The research prompt now asks for an
- * XML <report> element because thinking-mode models (DeepSeek V4)
- * produced malformed JSON often enough to derail the loop. We try
- * XML first, then JSON, then a free-text salvage.
- */
-export function parseReport(participant, text) {
-    if (!text || text.trim().length === 0) {
-        logger.warn("arena.parse_report_empty", { participant });
-        return {
-            participant,
-            contextSummary: "(no response)",
-            findings: [],
-        };
-    }
-    // (1) XML — preferred output format.
-    const xmlReport = tryParseReportXml(participant, text);
-    if (xmlReport && xmlReport.findings.length > 0)
-        return xmlReport;
-    // (2) JSON — older prompts, or models that still default to JSON.
-    try {
-        const json = extractJSON(text);
-        const parsed = JSON.parse(json);
-        let findings = parsed.findings;
-        if (!Array.isArray(findings) && parsed.contextSummary === undefined) {
-            if (parsed.kind && parsed.title) {
-                findings = [parsed];
-            }
-        }
-        const report = {
-            participant,
-            contextSummary: parsed.contextSummary ?? parsed.context_summary ?? "",
-            findings: Array.isArray(findings) ? findings.map(parseFinding) : [],
-        };
-        if (report.findings.length > 0)
-            return report;
-    }
-    catch (err) {
-        logger.warn("arena.parse_report_json_fail", {
-            participant,
-            error: err.message,
-            textLength: text.length,
-            text: text.slice(0, 500),
-        });
-    }
-    // (3) If XML had a contextSummary but zero findings, prefer that
-    // skeleton over a free-text salvage — the model committed to the
-    // schema but came up empty.
-    if (xmlReport) {
-        logger.warn("arena.parse_report_no_findings", {
-            participant,
-            textPreview: text.slice(0, 200),
-        });
-        return xmlReport;
-    }
-    // (4) Last resort.
-    return extractFindingsFromFreeText(participant, text);
-}
-/**
- * Tolerant XML parser scoped to <report>…</report>. Built by hand
- * (no full XML library) because the LLM output we accept is
- * shallow and well-known: <report><contextSummary/><findings>
- * <finding attrs…><title/><summary/><evidence/>* <affectedFiles/>?
- * <suggestedChange/>?</finding>*</findings></report>. Returns
- * undefined if no <report> root is present.
- */
-function tryParseReportXml(participant, text) {
-    const reportMatch = text.match(/<report\b[^>]*>([\s\S]*?)<\/report>/i);
-    if (!reportMatch)
-        return undefined;
-    const body = reportMatch[1];
-    const contextSummary = decodeXmlText(extractTag(body, "contextSummary") ?? "");
-    const findingsBlock = extractTag(body, "findings") ?? "";
-    const findings = [];
-    let i = 0;
-    for (const match of findingsBlock.matchAll(/<finding\b([^>]*)>([\s\S]*?)<\/finding>/gi)) {
-        const attrs = parseAttrs(match[1]);
-        const inner = match[2];
-        const title = decodeXmlText(extractTag(inner, "title") ?? "");
-        const summary = decodeXmlText(extractTag(inner, "summary") ?? "");
-        const evidence = [];
-        for (const ev of inner.matchAll(/<evidence\b([^>]*)>([\s\S]*?)<\/evidence>/gi)) {
-            const evAttrs = parseAttrs(ev[1]);
-            evidence.push({
-                type: (evAttrs.type ?? "doc"),
-                ref: evAttrs.ref ?? "",
-                note: decodeXmlText(ev[2].trim()),
-            });
-        }
-        const affectedFilesBlock = extractTag(inner, "affectedFiles") ?? "";
-        const affectedFiles = [];
-        for (const f of affectedFilesBlock.matchAll(/<file>([\s\S]*?)<\/file>/gi)) {
-            affectedFiles.push(decodeXmlText(f[1].trim()));
-        }
-        const suggestedChange = decodeXmlText(extractTag(inner, "suggestedChange") ?? "").trim();
-        const confidence = Number(attrs.confidence);
-        findings.push({
-            id: attrs.id || `f${i + 1}`,
-            kind: validateFindingKind(attrs.kind),
-            title: title || "Untitled",
-            summary,
-            severity: attrs.severity || undefined,
-            confidence: Number.isFinite(confidence) ? confidence : 0.5,
-            evidence,
-            affectedFiles,
-            suggestedChange: suggestedChange || undefined,
-        });
-        i++;
-    }
-    return { participant, contextSummary, findings };
-}
-function extractTag(xml, tag) {
-    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i");
-    const m = xml.match(re);
-    return m?.[1];
-}
-function parseAttrs(attrString) {
-    const out = {};
-    for (const m of attrString.matchAll(/(\w+)\s*=\s*"([^"]*)"/g)) {
-        out[m[1]] = m[2];
-    }
-    return out;
-}
-function decodeXmlText(s) {
-    return s
-        .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1")
-        .replace(/&lt;/g, "<")
-        .replace(/&gt;/g, ">")
-        .replace(/&quot;/g, '"')
-        .replace(/&apos;/g, "'")
-        .replace(/&amp;/g, "&")
-        .trim();
-}
-function parseFinding(raw, index) {
-    return {
-        id: asString(raw.id) || `f${index + 1}`,
-        kind: validateFindingKind(raw.kind),
-        title: asString(raw.title) || "Untitled",
-        summary: asString(raw.summary),
-        severity: raw.severity || undefined,
-        confidence: typeof raw.confidence === "number" ? raw.confidence : 0.5,
-        evidence: Array.isArray(raw.evidence)
-            ? raw.evidence.map((e) => ({
-                type: e.type ?? "doc",
-                ref: e.ref ?? "",
-                note: e.note ?? "",
-            }))
-            : [],
-        affectedFiles: Array.isArray(raw.affectedFiles) ? raw.affectedFiles : [],
-        suggestedChange: raw.suggestedChange || undefined,
-    };
-}
-function validateFindingKind(v) {
-    if (v === "strength" || v === "improvement" || v === "risk" || v === "question")
-        return v;
-    return "improvement";
-}
-/**
- * When JSON parsing fails, extract findings from free-text response.
- * Splits by paragraphs/sections and classifies each by keyword heuristics.
- */
-function extractFindingsFromFreeText(participant, text) {
-    // Split into meaningful sections (by headers, numbered lists, or double newlines)
-    const sections = text
-        .split(/(?:^|\n)(?:#{1,3}\s+|\d+\.\s+|\*\*[^*]+\*\*\s*\n|---+\s*\n)/m)
-        .map((s) => s.trim())
-        .filter((s) => s.length > 20);
-    if (sections.length === 0) {
-        // No structure found — use full text as one finding
-        return {
-            participant,
-            contextSummary: text.slice(0, 200),
-            findings: [{
-                    id: `${participant}-f1`,
-                    kind: "improvement",
-                    title: "Analysis",
-                    summary: text.slice(0, 3000),
-                    confidence: 0.5,
-                    evidence: [],
-                    affectedFiles: [],
-                }],
-        };
-    }
-    const findings = sections.slice(0, 10).map((section, i) => {
-        // Extract a title from the first line
-        const firstLine = section.split("\n")[0].slice(0, 100);
-        const body = section.length > firstLine.length
-            ? section.slice(firstLine.length).trim()
-            : section;
-        return {
-            id: `${participant}-f${i + 1}`,
-            kind: classifyFindingKind(section),
-            title: firstLine.replace(/^[-*•]\s*/, "").replace(/\*\*/g, ""),
-            summary: body.slice(0, 1000),
-            confidence: 0.5,
-            evidence: [],
-            affectedFiles: extractFilePaths(section),
-        };
-    });
-    return {
-        participant,
-        contextSummary: text.slice(0, 200),
-        findings,
-    };
-}
-/** Classify a free-text paragraph into a finding kind by keywords */
-function classifyFindingKind(text) {
-    const lower = text.toLowerCase();
-    if (/\b(risk|danger|vulnerab|security|breaking|regression|critical)\b/.test(lower))
-        return "risk";
-    if (/\b(good|well|strength|clean|solid|nice|excellent|properly)\b/.test(lower))
-        return "strength";
-    if (/\b(question|unclear|confirm|clarif|why|how come|wonder)\b/.test(lower))
-        return "question";
-    return "improvement";
-}
-/** Extract file paths from text (e.g. src/foo/bar.ts) */
-function extractFilePaths(text) {
-    const matches = text.match(/(?:^|\s)((?:src|lib|packages|app)\/[\w\-/.]+\.\w+)/gm);
-    return matches ? [...new Set(matches.map((m) => m.trim()))] : [];
-}
-/** Parse FindingReview[] from LLM JSON output */
-export function parseReviews(reviewer, text) {
-    try {
-        const json = extractJSONArray(text);
-        const parsed = JSON.parse(json);
-        if (!Array.isArray(parsed)) {
-            // Maybe it's wrapped in an object
-            const objJson = extractJSON(text);
-            const obj = JSON.parse(objJson);
-            if (Array.isArray(obj.reviews)) {
-                return obj.reviews.map((r) => parseReview(reviewer, r));
-            }
-            return [];
-        }
-        return parsed.map((r) => parseReview(reviewer, r));
-    }
-    catch {
-        return [];
-    }
-}
-function parseReview(reviewer, raw) {
-    return {
-        reviewer,
-        findingId: raw.findingId ?? raw.finding_id ?? "",
-        verdict: validateVerdict(raw.verdict),
-        reason: raw.reason ?? "",
-        extraEvidence: Array.isArray(raw.extraEvidence) ? raw.extraEvidence : undefined,
-    };
-}
-function validateVerdict(v) {
-    if (v === "agree" || v === "refine" || v === "disagree" || v === "needs_evidence")
-        return v;
-    return "agree";
-}
-/** Parse ArenaConsensus from LLM JSON output */
-export function parseConsensus(text) {
-    try {
-        const json = extractJSON(text);
-        const parsed = JSON.parse(json);
-        if (typeof parsed !== "object" || parsed === null) {
-            throw new Error("parsed JSON is not an object");
-        }
-        return {
-            summary: asString(parsed.summary),
-            subjectSummary: asString(parsed.subjectSummary || parsed.changeSummary) || undefined,
-            strengths: parseConsensusItems(parsed.strengths),
-            improvements: parseConsensusItems(parsed.improvements),
-            risks: parseConsensusItems(parsed.risks),
-            openQuestions: parseConsensusItems(parsed.openQuestions),
-            roadmap: parseRoadmapPhases(parsed.roadmap),
-            nextActions: Array.isArray(parsed.nextActions)
-                ? parsed.nextActions.map((a) => ({
-                    title: a.title ?? "",
-                    priority: validatePriority(a.priority),
-                    rationale: a.rationale ?? "",
-                    relatedFindings: Array.isArray(a.relatedFindings) ? a.relatedFindings : [],
-                }))
-                : [],
-        };
-    }
-    catch {
-        return {
-            summary: text,
-            strengths: [],
-            improvements: [],
-            risks: [],
-            openQuestions: [],
-            roadmap: [],
-            nextActions: [],
-        };
-    }
-}
-function parseConsensusItems(arr) {
-    if (!Array.isArray(arr))
-        return [];
-    return arr.map((item) => ({
-        title: asString(item.title),
-        summary: item.summary ?? "",
-        support: Array.isArray(item.support) ? item.support : [],
-        challenge: Array.isArray(item.challenge) ? item.challenge : [],
-        confidence: typeof item.confidence === "number" ? item.confidence : 0.5,
-        evidenceRefs: Array.isArray(item.evidenceRefs) ? item.evidenceRefs : [],
-    }));
-}
-function parseRoadmapPhases(arr) {
-    if (!Array.isArray(arr))
-        return [];
-    return arr.map((phase) => ({
-        title: phase.title ?? "",
-        priority: validatePriority(phase.priority),
-        goal: phase.goal ?? phase.description ?? "",
-        scope: toStringArray(phase.scope),
-        deliverables: toStringArray(phase.deliverables),
-        dependencies: toStringArray(phase.dependencies),
-        risks: toStringArray(phase.risks),
-        successCriteria: toStringArray(phase.successCriteria),
-        relatedFindings: toStringArray(phase.relatedFindings),
-    }));
-}
-function validatePriority(value) {
-    if (value === "high" || value === "medium" || value === "low")
-        return value;
-    return "medium";
-}
-function toStringArray(value) {
-    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-// ─── V2: Claim-Aware Formatters ─────────────────────────────────
-/** Format claims for verification-review prompts */
-export function formatClaimsForReview(claims) {
-    if (claims.length === 0)
-        return "No claims to review.";
-    return claims.map((c) => {
-        const f = c.finding;
-        const evidence = c.evidenceRefs.length > 0
-            ? `\n    Evidence: ${c.evidenceRefs.join(", ")}`
-            : "";
-        const packets = c.evidencePacketIds.length > 0
-            ? `\n    Evidence packets: ${c.evidencePacketIds.join(", ")}`
-            : "";
-        return (`- [${c.claimId}] (${f.kind}${f.severity ? `, ${f.severity}` : ""}, status: ${c.status})\n` +
-            `    ${sanitizeForPrompt(f.title)}\n` +
-            `    ${sanitizeForPrompt(f.summary)}` +
-            evidence +
-            packets +
-            `\n    Confidence: ${f.confidence}`);
-    }).join("\n\n");
-}
-/** Format debate history for debate turn prompts */
-export function formatDebateHistory(turns) {
-    if (turns.length === 0)
-        return "No prior debate turns.";
-    return turns.map((t) => `[${t.participant}] stance: ${t.stance}\n  ${t.summary}` +
-        (t.newEvidenceRefs?.length ? `\n  New evidence: ${t.newEvidenceRefs.join(", ")}` : "")).join("\n");
-}
-/** Format claim status summary for consensus prompts */
-export function formatClaimSummaryForConsensus(summary) {
-    const sections = [];
-    if (summary.verified.length > 0) {
-        sections.push(`### Verified Claims (${summary.verified.length})\n` +
-            summary.verified.map((c) => `- [${c.claimId}] ${sanitizeForPrompt(c.finding.title)} (${c.finding.kind}, confidence: ${c.finding.confidence})`).join("\n"));
-    }
-    if (summary.unresolved.length > 0) {
-        sections.push(`### Unresolved Claims (${summary.unresolved.length})\n` +
-            summary.unresolved.map((c) => `- [${c.claimId}] ${sanitizeForPrompt(c.finding.title)} — ${c.challenges.length} challenge(s), no consensus reached`).join("\n"));
-    }
-    if (summary.contested.length > 0) {
-        sections.push(`### Still Contested (${summary.contested.length})\n` +
-            summary.contested.map((c) => `- [${c.claimId}] ${sanitizeForPrompt(c.finding.title)} — ${c.challenges.length} challenge(s)`).join("\n"));
-    }
-    if (summary.rejected.length > 0) {
-        sections.push(`### Rejected Claims (${summary.rejected.length})\n` +
-            summary.rejected.map((c) => `- [${c.claimId}] ${sanitizeForPrompt(c.finding.title)} — rejected: ${sanitizeForPrompt(c.adjudication?.rationale ?? "no rationale")}`).join("\n"));
-    }
-    return sections.length > 0 ? sections.join("\n\n") : "No claims processed.";
-}
-/** Format a digest text block for inclusion in prompts */
-export function formatDigestForPrompt(digest) {
-    const sections = [];
-    sections.push(`Claims under review: ${digest.relevantClaimIds.join(", ")}`);
-    if (digest.evidencePackets.length > 0) {
-        sections.push("\nEvidence:");
-        for (const p of digest.evidencePackets) {
-            sections.push(`  [${p.packetId}] ${sanitizeForPrompt(p.title)} (${p.source}): ${sanitizeForPrompt(p.summary)}`);
-            for (const e of p.excerpts.slice(0, 2)) {
-                sections.push(`    > ${e.ref}: ${sanitizeForPrompt(e.snippet)}`);
-            }
-        }
-    }
-    if (digest.recentChallenges.length > 0) {
-        sections.push("\nPrior challenges:");
-        for (const c of digest.recentChallenges) {
-            sections.push(`  [${c.reviewer}] on ${c.claimId}: ${c.verdict} — ${sanitizeForPrompt(c.reason)}`);
-        }
-    }
-    return sections.join("\n");
-}
-// ─── V2: Claim-Aware Parsers ────────────────────────────────────
-/** Parse ClaimChallenge[] from LLM JSON output */
-export function parseChallenges(reviewer, text) {
-    try {
-        const json = extractJSONArray(text);
-        const parsed = JSON.parse(json);
-        if (!Array.isArray(parsed)) {
-            const objJson = extractJSON(text);
-            const obj = JSON.parse(objJson);
-            if (Array.isArray(obj.challenges)) {
-                return obj.challenges.map((r) => parseChallenge(reviewer, r));
-            }
-            return [];
-        }
-        return parsed.map((r) => parseChallenge(reviewer, r));
-    }
-    catch {
-        return [];
-    }
-}
-function parseChallenge(reviewer, raw) {
-    return {
-        reviewer,
-        claimId: asString(raw.claimId ?? raw.claim_id),
-        verdict: validateVerdict(raw.verdict),
-        reason: asString(raw.reason),
-        supportingEvidenceRefs: Array.isArray(raw.supportingEvidenceRefs)
-            ? raw.supportingEvidenceRefs
-            : undefined,
-        requestedChecks: Array.isArray(raw.requestedChecks)
-            ? raw.requestedChecks.map((rc) => ({
-                requestId: rc.requestId ?? `req-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-                claimId: raw.claimId ?? raw.claim_id ?? "",
-                requester: reviewer,
-                description: rc.description ?? "",
-                refs: Array.isArray(rc.refs) ? rc.refs : undefined,
-                priority: validateCheckPriority(rc.priority),
-            }))
-            : undefined,
-    };
-}
-function validateCheckPriority(v) {
-    if (v === "high" || v === "medium" || v === "low")
-        return v;
-    return undefined;
-}
-/** Parse a DebateTurn from LLM JSON output */
-export function parseDebateTurn(participant, text) {
-    try {
-        const json = extractJSON(text);
-        const parsed = JSON.parse(json);
-        return {
-            participant,
-            stance: validateStance(parsed.stance),
-            summary: parsed.summary ?? parsed.argument ?? "",
-            newEvidenceRefs: Array.isArray(parsed.newEvidenceRefs) ? parsed.newEvidenceRefs : undefined,
-        };
-    }
-    catch {
-        return {
-            participant,
-            stance: "uncertain",
-            summary: text.slice(0, 1000),
-        };
-    }
-}
-function validateStance(v) {
-    if (v === "support" || v === "oppose" || v === "narrow" || v === "uncertain")
-        return v;
-    return "uncertain";
-}
-/** Parse a ClaimAdjudication from LLM JSON output */
-export function parseAdjudication(claimId, text) {
-    try {
-        const json = extractJSON(text);
-        const parsed = JSON.parse(json);
-        return {
-            claimId,
-            outcome: validateAdjudicationOutcome(parsed.outcome),
-            rationale: asString(parsed.rationale),
-            finalSummary: asString(parsed.finalSummary ?? parsed.summary),
-            supportingEvidenceRefs: Array.isArray(parsed.supportingEvidenceRefs)
-                ? parsed.supportingEvidenceRefs
-                : [],
-        };
-    }
-    catch {
-        return {
-            claimId,
-            outcome: "unresolved",
-            rationale: "Failed to parse adjudication response",
-            finalSummary: text.slice(0, 500),
-            supportingEvidenceRefs: [],
-        };
-    }
-}
-function validateAdjudicationOutcome(v) {
-    if (v === "accepted" || v === "accepted_with_revision" || v === "rejected" || v === "unresolved")
-        return v;
-    return "unresolved";
-}
-// ─── Planning: Detail Expansion Parser ────────────────────────────
-/** Parse an ArenaRoadmapPhaseDetail from LLM JSON output */
-export function parseDetailExpansion(text) {
-    try {
-        const json = extractJSON(text);
-        const parsed = JSON.parse(json);
-        if (typeof parsed !== "object" || parsed === null) {
-            throw new Error("parsed JSON is not an object");
-        }
-        return {
-            phaseTitle: asString(parsed.phaseTitle),
-            objective: asString(parsed.objective),
-            targetFiles: toStringArray(parsed.targetFiles),
-            codeChanges: toStringArray(parsed.codeChanges),
-            interfaces: toStringArray(parsed.interfaces),
-            migrationSteps: toStringArray(parsed.migrationSteps),
-            validation: toStringArray(parsed.validation),
-            effort: validateEffort(parsed.effort),
-            blockers: toStringArray(parsed.blockers),
-            evidenceRefs: toStringArray(parsed.evidenceRefs),
-        };
-    }
-    catch {
-        return {
-            phaseTitle: "",
-            objective: text.slice(0, 500),
-            targetFiles: [],
-            codeChanges: [],
-            interfaces: [],
-            migrationSteps: [],
-            validation: [],
-            effort: "medium",
-            blockers: [],
-            evidenceRefs: [],
-        };
-    }
-}
-function validateEffort(v) {
-    if (v === "small" || v === "medium" || v === "large")
-        return v;
-    return "medium";
-}

package/dist/arena/tools/selector.d.ts

@@ -1,17 +0,0 @@
-/**
- * ArenaToolSelector — selects tool packs based on ArenaPlan sources.
- *
- * Maps evidence sources to subsets of the existing context tools.
- * This replaces the hard-coded "always give all tools" approach.
- */
-import type { ArenaPlan } from "../types.js";
-import type { ToolDefinition } from "../../types.js";
-/**
- * Select the appropriate tools for a given plan.
- * Merges tool packs from all active sources, deduplicating by name.
- */
-export declare function selectTools(plan: ArenaPlan): ToolDefinition[];
-/**
- * Check whether any tools are available for the plan.
- */
-export declare function hasTools(plan: ArenaPlan): boolean;

package/dist/arena/tools/selector.js

@@ -1,61 +0,0 @@
-/**
- * ArenaToolSelector — selects tool packs based on ArenaPlan sources.
- *
- * Maps evidence sources to subsets of the existing context tools.
- * This replaces the hard-coded "always give all tools" approach.
- */
-import { CONTEXT_TOOLS } from "../context/context-tools.js";
-/** Predefined tool packs by source kind */
-const TOOL_PACKS = {
-    repo_readonly: {
-        name: "repo_readonly",
-        toolNames: ["read_file", "grep_code", "list_files"],
-    },
-    git: {
-        name: "git",
-        toolNames: ["read_file", "grep_code", "list_files", "git_show", "git_blame"],
-    },
-    docs: {
-        name: "docs",
-        toolNames: ["read_file", "list_files"],
-    },
-    no_tools: {
-        name: "no_tools",
-        toolNames: [],
-    },
-};
-/** Map source kind to default tool pack */
-const SOURCE_TO_PACK = {
-    git: "git",
-    repo: "repo_readonly",
-    docs: "docs",
-    web: "no_tools", // web tools not yet available in arena context
-    none: "no_tools",
-};
-/**
- * Select the appropriate tools for a given plan.
- * Merges tool packs from all active sources, deduplicating by name.
- */
-export function selectTools(plan) {
-    const toolNames = new Set();
-    for (const source of plan.sources) {
-        const packName = source.toolPack ?? SOURCE_TO_PACK[source.kind] ?? "no_tools";
-        const pack = TOOL_PACKS[packName] ?? TOOL_PACKS.no_tools;
-        for (const name of pack.toolNames) {
-            toolNames.add(name);
-        }
-    }
-    if (toolNames.size === 0)
-        return [];
-    return CONTEXT_TOOLS.filter((t) => toolNames.has(t.name));
-}
-/**
- * Check whether any tools are available for the plan.
- */
-export function hasTools(plan) {
-    return plan.sources.some((s) => {
-        const packName = SOURCE_TO_PACK[s.kind];
-        const pack = TOOL_PACKS[packName];
-        return pack && pack.toolNames.length > 0;
-    });
-}