@cjhyy/code-shell-core 0.7.0 → 0.8.0

package/dist/arena/detect-mode.js

@@ -1,78 +0,0 @@
-/**
- * Arena mode auto-detection — infer review/discussion/planning from topic text.
- *
- * Heuristic-based: uses keyword matching with weighted scoring.
- * Falls back to "review" (safest default) when confidence is low.
- */
-const MODE_SIGNALS = {
-    review: [
-        { patterns: [/\breview\b/i, /\baudit\b/i, /\binspect\b/i, /\bcheck\b/i], weight: 2 },
-        { patterns: [/\bcode\s*quality\b/i, /\bbug\b/i, /\bvulnerab/i, /\bsecur/i] },
-        { patterns: [/\bpr\b/i, /\bpull\s*request\b/i, /\bdiff\b/i, /\bchanges?\b/i] },
-        { patterns: [/\brefactor/i, /\bclean\s*up\b/i, /\bimprove\b/i] },
-    ],
-    discussion: [
-        { patterns: [/\bdiscuss\b/i, /\bdebate\b/i, /\bcompare\b/i], weight: 2 },
-        { patterns: [/\bpros?\s*(and|&|\/)\s*cons?\b/i, /\btrade\s*-?\s*offs?\b/i] },
-        { patterns: [/\bshould\s+we\b/i, /\bwhich\s+(is|approach|way)\b/i, /\bvs\.?\b/i] },
-        { patterns: [/\bopinion\b/i, /\bthoughts?\b/i, /\badvice\b/i] },
-    ],
-    planning: [
-        { patterns: [/\bplan\b/i, /\bplanning\b/i, /\broadmap\b/i, /\bstrategy\b/i], weight: 2 },
-        { patterns: [/\barchitect/i, /\bdesign\b/i, /\bproposal\b/i] },
-        { patterns: [/\bimplement(ation)?\s+(plan|strategy|approach)\b/i], weight: 2 },
-        { patterns: [/\bphase\b/i, /\bmilestone\b/i, /\btimeline\b/i, /\bprioritiz/i] },
-        { patterns: [/\bbuild\b/i, /\bcreate\b/i, /\bsetup\b/i, /\bbootstrap\b/i] },
-    ],
-};
-/** Confidence threshold: below this → low confidence */
-const HIGH_CONFIDENCE_THRESHOLD = 3;
-/** Minimum lead over runner-up to be "high" confidence */
-const MIN_LEAD = 2;
-// ─── Detection ──────────────────────────────────────────────────
-/**
- * Auto-detect arena mode from the topic string.
- *
- * Returns the detected mode, confidence level, and a human-readable reason.
- * When confidence is low, falls back to "review" (the safest default).
- */
-export function detectArenaMode(topic) {
-    const scores = { review: 0, discussion: 0, planning: 0 };
-    for (const [mode, signals] of Object.entries(MODE_SIGNALS)) {
-        for (const signal of signals) {
-            const weight = signal.weight ?? 1;
-            for (const pattern of signal.patterns) {
-                if (pattern.test(topic)) {
-                    scores[mode] += weight;
-                }
-            }
-        }
-    }
-    // Sort modes by score descending
-    const ranked = Object.entries(scores)
-        .sort((a, b) => b[1] - a[1]);
-    const [bestMode, bestScore] = ranked[0];
-    const [, runnerUpScore] = ranked[1];
-    const lead = bestScore - runnerUpScore;
-    // Determine confidence
-    if (bestScore >= HIGH_CONFIDENCE_THRESHOLD && lead >= MIN_LEAD) {
-        return {
-            mode: bestMode,
-            confidence: "high",
-            reason: `Topic strongly matches "${bestMode}" (score: ${bestScore}, lead: +${lead})`,
-        };
-    }
-    if (bestScore > 0 && lead > 0) {
-        return {
-            mode: bestMode,
-            confidence: "low",
-            reason: `Topic weakly matches "${bestMode}" (score: ${bestScore}, lead: +${lead})`,
-        };
-    }
-    // No signal at all → default to review
-    return {
-        mode: "review",
-        confidence: "low",
-        reason: "No strong mode signal detected, defaulting to review",
-    };
-}

package/dist/arena/digest-builder.d.ts

@@ -1,25 +0,0 @@
-/**
- * DigestBuilder — constructs RoundResearchDigest from the shared ledger.
- *
- * The digest is a filtered view injected into prompts to avoid
- * token explosion from the full ledger. Program-built, not model-built.
- */
-import type { ArenaLedger } from "./ledger.js";
-import type { RoundResearchDigest } from "./types.js";
-interface DigestOptions {
-    /** Current round number */
-    round: number;
-    /** Claim IDs relevant to this round (e.g. contested claims in debate) */
-    relevantClaimIds: string[];
-}
-/**
- * Build a digest from the shared ledger for a specific round.
- * Only includes data relevant to the specified claims.
- */
-export declare function buildDigest(ledger: ArenaLedger, options: DigestOptions): RoundResearchDigest;
-/**
- * Format a digest into a text block suitable for prompt injection.
- * All LLM-originated text is sanitized before inclusion.
- */
-export declare function formatDigest(digest: RoundResearchDigest): string;
-export {};

package/dist/arena/digest-builder.js

@@ -1,120 +0,0 @@
-/**
- * DigestBuilder — constructs RoundResearchDigest from the shared ledger.
- *
- * The digest is a filtered view injected into prompts to avoid
- * token explosion from the full ledger. Program-built, not model-built.
- */
-/**
- * Build a digest from the shared ledger for a specific round.
- * Only includes data relevant to the specified claims.
- */
-export function buildDigest(ledger, options) {
-    const { round, relevantClaimIds } = options;
-    const claimIdSet = new Set(relevantClaimIds);
-    const snapshot = ledger.getSnapshot();
-    // Collect evidence packets referenced by relevant claims
-    const packetIds = new Set();
-    for (const claimId of relevantClaimIds) {
-        const claim = ledger.getClaimById(claimId);
-        if (claim) {
-            for (const pid of claim.evidencePacketIds) {
-                packetIds.add(pid);
-            }
-        }
-    }
-    const evidencePackets = [];
-    for (const pid of packetIds) {
-        const packet = ledger.getPacketById(pid);
-        if (packet)
-            evidencePackets.push(packet);
-    }
-    // Tool trace summary — built directly from dossiers to preserve participant ownership
-    const toolTraceSummary = [];
-    for (const dossier of snapshot.dossiers) {
-        for (const trace of dossier.toolTrace) {
-            if (trace.keptAsEvidence) {
-                toolTraceSummary.push({
-                    participant: dossier.participant,
-                    toolName: trace.toolName,
-                    ref: trace.resultRef,
-                });
-            }
-        }
-    }
-    // Recent challenges for relevant claims
-    const recentChallenges = snapshot.challenges
-        .filter((c) => claimIdSet.has(c.claimId));
-    // Pending requested checks for relevant claims
-    const requestedChecks = snapshot.requestedChecks
-        .filter((c) => claimIdSet.has(c.claimId));
-    // Prior adjudications for relevant claims
-    const priorAdjudications = snapshot.adjudications
-        .filter((a) => claimIdSet.has(a.claimId));
-    return {
-        round,
-        relevantClaimIds,
-        evidencePackets,
-        toolTraceSummary,
-        recentChallenges,
-        requestedChecks,
-        priorAdjudications,
-    };
-}
-/**
- * Sanitize text from LLM output before re-injecting into a prompt.
- * Strips patterns that could be interpreted as prompt-level instructions.
- */
-function sanitize(text) {
-    if (!text)
-        return "";
-    return text
-        // Strip fake system/assistant role tags
-        .replace(/<\/?(?:system|assistant|user|system-reminder)[^>]*>/gi, "")
-        // Strip instruction-like prefixes (case-insensitive)
-        .replace(/^(?:IGNORE|DISREGARD|FORGET|OVERRIDE|SYSTEM|INSTRUCTION)[:\s].*/gim, "")
-        // Collapse excessive whitespace
-        .replace(/\n{3,}/g, "\n\n")
-        // Limit length per field
-        .slice(0, 2000);
-}
-/**
- * Format a digest into a text block suitable for prompt injection.
- * All LLM-originated text is sanitized before inclusion.
- */
-export function formatDigest(digest) {
-    const sections = [];
-    sections.push(`## Round ${digest.round} Research Digest`);
-    sections.push(`Claims under consideration: ${digest.relevantClaimIds.join(", ")}`);
-    if (digest.evidencePackets.length > 0) {
-        sections.push("\n### Evidence");
-        for (const packet of digest.evidencePackets) {
-            sections.push(`- [${packet.packetId}] ${sanitize(packet.title)} (${packet.source})`);
-            sections.push(`  ${sanitize(packet.summary)}`);
-            for (const excerpt of packet.excerpts.slice(0, 3)) {
-                sections.push(`  > ${excerpt.ref}: ${sanitize(excerpt.snippet)}`);
-                if (excerpt.note)
-                    sections.push(`    Note: ${sanitize(excerpt.note)}`);
-            }
-        }
-    }
-    if (digest.recentChallenges.length > 0) {
-        sections.push("\n### Challenges");
-        for (const c of digest.recentChallenges) {
-            sections.push(`- [${c.reviewer}] on ${c.claimId}: ${c.verdict} — ${sanitize(c.reason)}`);
-        }
-    }
-    if (digest.requestedChecks.length > 0) {
-        sections.push("\n### Requested Checks");
-        for (const check of digest.requestedChecks) {
-            const pri = check.priority ? ` (${check.priority})` : "";
-            sections.push(`- [${check.requestId}]${pri}: ${sanitize(check.description)}`);
-        }
-    }
-    if (digest.priorAdjudications.length > 0) {
-        sections.push("\n### Prior Adjudications");
-        for (const adj of digest.priorAdjudications) {
-            sections.push(`- ${adj.claimId}: ${adj.outcome} — ${sanitize(adj.rationale)}`);
-        }
-    }
-    return sections.join("\n");
-}

package/dist/arena/index.d.ts

@@ -1,29 +0,0 @@
-/**
- * Arena — multi-model collaborative analysis (Evidence-Driven).
- */
-export { Arena } from "./arena.js";
-export { MODEL_PRESETS, getMaxOutputTokens } from "./model-presets.js";
-export type { ModelPreset } from "./model-presets.js";
-export { getStrategy, getStrategyForPlan, ReviewStrategy, DiscussionStrategy, PlanningStrategy } from "./strategies/index.js";
-export { planArena } from "./planner.js";
-export { collectEvidence } from "./providers/index.js";
-export { selectTools, hasTools } from "./tools/selector.js";
-export { getLens, resolveLenses, buildLensPrompt, LENS_NAMES } from "./lenses/index.js";
-export { runParticipantResearch, runParticipantResearchWithDossiers } from "./phases/participant-research.js";
-export type { ResearchResult } from "./phases/participant-research.js";
-export { runCrossReview, runVerificationReview } from "./phases/cross-review.js";
-export { runDebateRounds } from "./phases/debate-rounds.js";
-export { runAdjudication } from "./phases/adjudication.js";
-export { buildConsensus } from "./phases/build-consensus.js";
-export { registerClaims, selectClaimsForReview } from "./phases/claim-registry.js";
-export { ArenaLedger } from "./ledger.js";
-export { buildDigest, formatDigest } from "./digest-builder.js";
-export { transitionClaim, resolveClaimStatus, markUnderReview, applyReviewResult, markUnresolved, isTerminal, validTransitions, } from "./transitions.js";
-export { formatArenaResult, printArenaResult, renderProgress, createProgressRenderer } from "./render/terminal.js";
-export type { OutputSink } from "./render/terminal.js";
-export { formatArenaResultForSession } from "./render/session.js";
-export type { ArenaConfig, ArenaResultV2, ArenaStrategy, ArenaStrategyV2, ClaimStatusSummary, ArenaParticipant, ArenaBaseContext, ArenaFinding, FindingReview, ParticipantReport, ArenaConsensus, ArenaConsensusItem, ArenaRoadmapPhase, ArenaProgressEvent, ArenaMode, FindingKind, PeerVerdict, ArenaPlan, ArenaLens, ArenaLensName, ArenaLensRef, ArenaSourceKind, ArenaSourceSpec, ArenaSubject, ArenaOutputShape, ArenaArtifact, ArenaToolPack, ArenaContextProvider, ArenaQuickFact, ToolTrace, EvidencePacket, FindingEvidenceLink, ResearchDossier, ClaimStatus, ClaimRecord, ClaimChallenge, ClaimAdjudication, RequestedCheck, DebateRound, DebateTurn, TargetedCheckTask, SharedResearchLedger, RoundResearchDigest, ArenaExecutionLimits, } from "./types.js";
-export { isStrategyV2 } from "./types.js";
-export { IterativeArena } from "./iterate/index.js";
-export { defaultConvergence as defaultIterateConvergence, diffRatio as iterateDiffRatio, codeFormat as iterateCodeFormat, documentFormat as iterateDocumentFormat, getFormat as getIterateFormat, } from "./iterate/index.js";
-export type { AuthorRotation, CheckpointAction, CheckpointContext, CheckpointFn, ConvergenceSignal, Critique, CritiqueCategory, CritiqueEvidence, CritiqueSeverity, Draft, DraftCandidate, IterateConfig, IterateFormat, IterateProgressEvent, IterateResult, IterateSubject, Round, StoppedReason, FormatPack as IterateFormatPack, } from "./iterate/index.js";

package/dist/arena/index.js

@@ -1,29 +0,0 @@
-/**
- * Arena — multi-model collaborative analysis (Evidence-Driven).
- */
-export { Arena } from "./arena.js";
-export { MODEL_PRESETS, getMaxOutputTokens } from "./model-presets.js";
-export { getStrategy, getStrategyForPlan, ReviewStrategy, DiscussionStrategy, PlanningStrategy } from "./strategies/index.js";
-export { planArena } from "./planner.js";
-export { collectEvidence } from "./providers/index.js";
-export { selectTools, hasTools } from "./tools/selector.js";
-export { getLens, resolveLenses, buildLensPrompt, LENS_NAMES } from "./lenses/index.js";
-export { runParticipantResearch, runParticipantResearchWithDossiers } from "./phases/participant-research.js";
-export { runCrossReview, runVerificationReview } from "./phases/cross-review.js";
-export { runDebateRounds } from "./phases/debate-rounds.js";
-export { runAdjudication } from "./phases/adjudication.js";
-export { buildConsensus } from "./phases/build-consensus.js";
-export { registerClaims, selectClaimsForReview } from "./phases/claim-registry.js";
-export { ArenaLedger } from "./ledger.js";
-export { buildDigest, formatDigest } from "./digest-builder.js";
-export { transitionClaim, resolveClaimStatus, markUnderReview, applyReviewResult, markUnresolved, isTerminal, validTransitions, } from "./transitions.js";
-export { formatArenaResult, printArenaResult, renderProgress, createProgressRenderer } from "./render/terminal.js";
-export { formatArenaResultForSession } from "./render/session.js";
-export { isStrategyV2 } from "./types.js";
-// ─── Iterate Mode ────────────────────────────────────────────────
-//
-// Iterative authoring loop: tournament v1 → critique-revise rounds.
-// Use this for "produce a thing from scratch" (code, PRD, design doc).
-// For "review an existing thing" use the regular Arena class above.
-export { IterativeArena } from "./iterate/index.js";
-export { defaultConvergence as defaultIterateConvergence, diffRatio as iterateDiffRatio, codeFormat as iterateCodeFormat, documentFormat as iterateDocumentFormat, getFormat as getIterateFormat, } from "./iterate/index.js";

package/dist/arena/iterate/convergence.d.ts

@@ -1,25 +0,0 @@
-/**
- * Convergence detection — when has the draft stabilized enough to stop?
- */
-import type { ConvergenceSignal, Critique, Draft } from "./types.js";
-/**
- * Cheap O(n) approximation of "how different is new vs old".
- * Returns 0..1 where 0 = identical, 1 = completely different.
- *
- * Uses character-trigram Jaccard distance — fast, good enough for "is the
- * author actually changing anything substantial?".
- */
-export declare function diffRatio(a: string, b: string): number;
-/**
- * Default convergence rule:
- *   stop if blockers == 0 AND
- *     (all critiques are minor/nit/praise OR diff < 5% from last version)
- *
- * Round 1 never converges (need at least one revision pass).
- */
-export declare function defaultConvergence(args: {
-    round: number;
-    critiques: Critique[];
-    draft: Draft;
-    previousDraft?: Draft;
-}): ConvergenceSignal;

package/dist/arena/iterate/convergence.js

@@ -1,103 +0,0 @@
-/**
- * Convergence detection — when has the draft stabilized enough to stop?
- */
-/**
- * Cheap O(n) approximation of "how different is new vs old".
- * Returns 0..1 where 0 = identical, 1 = completely different.
- *
- * Uses character-trigram Jaccard distance — fast, good enough for "is the
- * author actually changing anything substantial?".
- */
-export function diffRatio(a, b) {
-    if (a === b)
-        return 0;
-    if (!a || !b)
-        return 1;
-    const trigrams = (s) => {
-        const out = new Set();
-        for (let i = 0; i < s.length - 2; i++)
-            out.add(s.slice(i, i + 3));
-        return out;
-    };
-    const A = trigrams(a);
-    const B = trigrams(b);
-    let inter = 0;
-    for (const t of A)
-        if (B.has(t))
-            inter++;
-    const union = A.size + B.size - inter;
-    if (union === 0)
-        return 0;
-    const jaccard = inter / union; // similarity
-    return 1 - jaccard;
-}
-/**
- * Default convergence rule:
- *   stop if blockers == 0 AND
- *     (all critiques are minor/nit/praise OR diff < 5% from last version)
- *
- * Round 1 never converges (need at least one revision pass).
- */
-export function defaultConvergence(args) {
-    const { round, critiques, draft, previousDraft } = args;
-    const blockerCount = critiques.filter((c) => c.severity === "blocker").length;
-    const majorCount = critiques.filter((c) => c.severity === "major").length;
-    const totalCritiques = critiques.length;
-    const diffFromPrevious = previousDraft ? diffRatio(previousDraft.content, draft.content) : 1;
-    // Round 1 (the v1) — always do at least one revision pass, never converge here.
-    if (round === 1) {
-        return {
-            blockerCount,
-            majorCount,
-            totalCritiques,
-            diffFromPrevious,
-            shouldStop: false,
-            reason: "running",
-        };
-    }
-    // Special case: zero critiques is almost always a parsing/timeout failure
-    // on the critic side, NOT a sign of convergence. Treat as "running" so
-    // the next round has a chance — the loop will naturally stop at maxRounds.
-    if (totalCritiques === 0) {
-        return {
-            blockerCount,
-            majorCount,
-            totalCritiques,
-            diffFromPrevious,
-            shouldStop: false,
-            reason: "running",
-        };
-    }
-    // Hard floor: no blockers AND no majors → all that's left is polish.
-    // Require at least 3 critiques so a single low-effort response can't
-    // declare false convergence.
-    if (blockerCount === 0 && majorCount === 0 && totalCritiques >= 3) {
-        return {
-            blockerCount,
-            majorCount,
-            totalCritiques,
-            diffFromPrevious,
-            shouldStop: true,
-            reason: "all_minor_or_praise",
-        };
-    }
-    // Soft floor: no blockers AND draft barely moved → author is stuck or done.
-    if (blockerCount === 0 && diffFromPrevious < 0.05) {
-        return {
-            blockerCount,
-            majorCount,
-            totalCritiques,
-            diffFromPrevious,
-            shouldStop: true,
-            reason: "blockers_zero_and_stable",
-        };
-    }
-    return {
-        blockerCount,
-        majorCount,
-        totalCritiques,
-        diffFromPrevious,
-        shouldStop: false,
-        reason: "running",
-    };
-}

package/dist/arena/iterate/formats/index.d.ts

@@ -1,22 +0,0 @@
-/**
- * Format packs — prompt templates for code vs document iteration.
- *
- * Each format provides four prompt builders:
- *   - draftPrompt:    used in tournament v1 (every participant writes a candidate)
- *   - mergePrompt:    used in v1 merge (author reads anonymized candidates → v1)
- *   - argueSystem:    system prompt for critics
- *   - argueUser:      user prompt that wraps the current draft for critique
- *   - revisePrompt:   used to produce v(N+1) given v(N) + critiques
- */
-import type { Critique, Draft, DraftCandidate, IterateFormat, IterateSubject } from "../types.js";
-export interface FormatPack {
-    format: IterateFormat;
-    draftPrompt(subject: IterateSubject, minLength: number): string;
-    mergePrompt(subject: IterateSubject, candidates: DraftCandidate[], minLength: number): string;
-    argueSystem(format: IterateFormat): string;
-    argueUser(subject: IterateSubject, draft: Draft, lens?: string): string;
-    revisePrompt(subject: IterateSubject, previous: Draft, critiques: Critique[], minLength: number): string;
-}
-export declare const codeFormat: FormatPack;
-export declare const documentFormat: FormatPack;
-export declare function getFormat(format: IterateFormat): FormatPack;