@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/arena/tools/selector.js

@@ -0,0 +1,61 @@
+/**
+ * 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;
+    });
+}

package/dist/arena/transitions.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Claim state machine — centralized transition rules.
+ *
+ * All claim status changes go through this module to enforce
+ * consistent state transitions across phases.
+ *
+ * State machine:
+ *   proposed → under_review
+ *   under_review → verified | contested | rejected
+ *   contested → under_review | unresolved | verified | rejected
+ */
+import type { ClaimRecord, ClaimStatus, ClaimChallenge } from "./types.js";
+/**
+ * Attempt to transition a claim to a new status.
+ * Returns true if the transition was applied, false if invalid.
+ */
+export declare function transitionClaim(claim: ClaimRecord, to: ClaimStatus): boolean;
+/**
+ * Determine the next status for a claim based on its challenges.
+ *
+ * Rules:
+ * - No challenges → stays as-is (unreviewed is NOT verified)
+ * - Any "disagree" → contested
+ * - Any "needs_evidence" → contested
+ * - Pending checks exist → contested
+ * - At least one explicit "agree" and all others "agree"/"refine" → verified
+ */
+export declare function resolveClaimStatus(claim: ClaimRecord, challenges: ClaimChallenge[], hasPendingChecks: boolean): ClaimStatus;
+/**
+ * Mark a claim as entering review.
+ */
+export declare function markUnderReview(claim: ClaimRecord): boolean;
+/**
+ * Apply review results to a claim and transition appropriately.
+ */
+export declare function applyReviewResult(claim: ClaimRecord, challenges: ClaimChallenge[], hasPendingChecks: boolean): void;
+/**
+ * Mark a contested claim as unresolved (budget/round exhausted).
+ */
+export declare function markUnresolved(claim: ClaimRecord): boolean;
+/**
+ * Check if a claim is in a terminal state (no further transitions possible).
+ */
+export declare function isTerminal(claim: ClaimRecord): boolean;
+/**
+ * Get valid next statuses for a claim.
+ */
+export declare function validTransitions(claim: ClaimRecord): ClaimStatus[];

package/dist/arena/transitions.js

@@ -0,0 +1,92 @@
+/**
+ * Claim state machine — centralized transition rules.
+ *
+ * All claim status changes go through this module to enforce
+ * consistent state transitions across phases.
+ *
+ * State machine:
+ *   proposed → under_review
+ *   under_review → verified | contested | rejected
+ *   contested → under_review | unresolved | verified | rejected
+ */
+/** Valid transitions from each status */
+const VALID_TRANSITIONS = {
+    proposed: ["under_review"],
+    under_review: ["verified", "contested", "rejected"],
+    contested: ["under_review", "unresolved", "verified", "rejected"],
+    verified: [],
+    rejected: [],
+    unresolved: [],
+};
+/**
+ * Attempt to transition a claim to a new status.
+ * Returns true if the transition was applied, false if invalid.
+ */
+export function transitionClaim(claim, to) {
+    const allowed = VALID_TRANSITIONS[claim.status];
+    if (!allowed.includes(to)) {
+        return false;
+    }
+    claim.status = to;
+    return true;
+}
+/**
+ * Determine the next status for a claim based on its challenges.
+ *
+ * Rules:
+ * - No challenges → stays as-is (unreviewed is NOT verified)
+ * - Any "disagree" → contested
+ * - Any "needs_evidence" → contested
+ * - Pending checks exist → contested
+ * - At least one explicit "agree" and all others "agree"/"refine" → verified
+ */
+export function resolveClaimStatus(claim, challenges, hasPendingChecks) {
+    // No challenges = no review happened — do not auto-verify
+    if (challenges.length === 0)
+        return claim.status;
+    const verdicts = challenges.map((c) => c.verdict);
+    if (verdicts.includes("disagree") || verdicts.includes("needs_evidence")) {
+        return "contested";
+    }
+    if (hasPendingChecks) {
+        return "contested";
+    }
+    // Require at least one explicit "agree" to mark as verified
+    // (not just all "refine" with no agreement)
+    if (verdicts.includes("agree")) {
+        return "verified";
+    }
+    // All "refine" without any "agree" — keep under review, not yet verified
+    return claim.status;
+}
+/**
+ * Mark a claim as entering review.
+ */
+export function markUnderReview(claim) {
+    return transitionClaim(claim, "under_review");
+}
+/**
+ * Apply review results to a claim and transition appropriately.
+ */
+export function applyReviewResult(claim, challenges, hasPendingChecks) {
+    const nextStatus = resolveClaimStatus(claim, challenges, hasPendingChecks);
+    transitionClaim(claim, nextStatus);
+}
+/**
+ * Mark a contested claim as unresolved (budget/round exhausted).
+ */
+export function markUnresolved(claim) {
+    return transitionClaim(claim, "unresolved");
+}
+/**
+ * Check if a claim is in a terminal state (no further transitions possible).
+ */
+export function isTerminal(claim) {
+    return VALID_TRANSITIONS[claim.status].length === 0;
+}
+/**
+ * Get valid next statuses for a claim.
+ */
+export function validTransitions(claim) {
+    return VALID_TRANSITIONS[claim.status];
+}