@opencode_weave/weave 0.7.0 → 0.7.3

package/dist/features/evals/types.d.ts

@@ -0,0 +1,223 @@
+import type { WeaveAgentName } from "../../agents/types";
+export declare const EVAL_PHASES: readonly ["phase1", "phase2", "phase3", "phase4"];
+export type EvalPhase = (typeof EVAL_PHASES)[number];
+export declare const EVAL_TARGET_KINDS: readonly ["builtin-agent-prompt", "custom-agent-prompt", "single-turn-agent", "trajectory-agent"];
+export type EvalTargetKind = (typeof EVAL_TARGET_KINDS)[number];
+export declare const EXECUTOR_KINDS: readonly ["prompt-render", "model-response", "trajectory-run"];
+export type ExecutorKind = (typeof EXECUTOR_KINDS)[number];
+export declare const EVALUATOR_KINDS: readonly ["contains-all", "contains-any", "excludes-all", "section-contains-all", "ordered-contains", "xml-sections-present", "tool-policy", "min-length", "llm-judge", "baseline-diff", "trajectory-assertion"];
+export type EvaluatorKind = (typeof EVALUATOR_KINDS)[number];
+export type BuiltinEvalAgentName = Exclude<WeaveAgentName, "shuttle">;
+export interface BuiltinAgentPromptVariant {
+    disabledAgents?: string[];
+}
+export interface BuiltinAgentPromptTarget {
+    kind: "builtin-agent-prompt";
+    agent: BuiltinEvalAgentName;
+    variant?: BuiltinAgentPromptVariant;
+}
+export interface CustomAgentPromptTarget {
+    kind: "custom-agent-prompt";
+    agentId: string;
+}
+export interface SingleTurnAgentTarget {
+    kind: "single-turn-agent";
+    agent: string;
+    input?: string;
+}
+export interface TrajectoryAgentTarget {
+    kind: "trajectory-agent";
+    agent: string;
+    scenarioRef?: string;
+}
+export type EvalTarget = BuiltinAgentPromptTarget | CustomAgentPromptTarget | SingleTurnAgentTarget | TrajectoryAgentTarget;
+export interface PromptRenderExecutor {
+    kind: "prompt-render";
+}
+export interface ModelResponseExecutor {
+    kind: "model-response";
+    provider: string;
+    model: string;
+    input: string;
+}
+export interface TrajectoryRunExecutor {
+    kind: "trajectory-run";
+    scenarioRef: string;
+}
+export type ExecutorSpec = PromptRenderExecutor | ModelResponseExecutor | TrajectoryRunExecutor;
+export interface WeightedEvaluatorSpec {
+    weight?: number;
+}
+export interface ContainsAllEvaluator extends WeightedEvaluatorSpec {
+    kind: "contains-all";
+    patterns: string[];
+}
+export interface ContainsAnyEvaluator extends WeightedEvaluatorSpec {
+    kind: "contains-any";
+    patterns: string[];
+}
+export interface ExcludesAllEvaluator extends WeightedEvaluatorSpec {
+    kind: "excludes-all";
+    patterns: string[];
+}
+export interface SectionContainsAllEvaluator extends WeightedEvaluatorSpec {
+    kind: "section-contains-all";
+    section: string;
+    patterns: string[];
+}
+export interface OrderedContainsEvaluator extends WeightedEvaluatorSpec {
+    kind: "ordered-contains";
+    patterns: string[];
+}
+export interface XmlSectionsPresentEvaluator extends WeightedEvaluatorSpec {
+    kind: "xml-sections-present";
+    sections: string[];
+}
+export interface ToolPolicyEvaluator extends WeightedEvaluatorSpec {
+    kind: "tool-policy";
+    expectations: Record<string, boolean>;
+}
+export interface MinLengthEvaluator extends WeightedEvaluatorSpec {
+    kind: "min-length";
+    min: number;
+}
+export interface LlmJudgeEvaluator extends WeightedEvaluatorSpec {
+    kind: "llm-judge";
+    rubricRef?: string;
+    expectedContains?: string[];
+    forbiddenContains?: string[];
+}
+export interface BaselineDiffEvaluator extends WeightedEvaluatorSpec {
+    kind: "baseline-diff";
+    baselineRef?: string;
+}
+export interface TrajectoryAssertionEvaluator extends WeightedEvaluatorSpec {
+    kind: "trajectory-assertion";
+    assertionRef?: string;
+}
+export type EvaluatorSpec = ContainsAllEvaluator | ContainsAnyEvaluator | ExcludesAllEvaluator | SectionContainsAllEvaluator | OrderedContainsEvaluator | XmlSectionsPresentEvaluator | ToolPolicyEvaluator | MinLengthEvaluator | LlmJudgeEvaluator | BaselineDiffEvaluator | TrajectoryAssertionEvaluator;
+export interface EvalSuiteManifest {
+    id: string;
+    title: string;
+    phase: EvalPhase;
+    caseFiles: string[];
+    tags?: string[];
+}
+export interface EvalCase {
+    id: string;
+    title: string;
+    phase: EvalPhase;
+    target: EvalTarget;
+    executor: ExecutorSpec;
+    evaluators: EvaluatorSpec[];
+    tags?: string[];
+    notes?: string;
+}
+export interface LoadedEvalSuiteManifest extends EvalSuiteManifest {
+    filePath: string;
+}
+export interface LoadedEvalCase extends EvalCase {
+    filePath: string;
+}
+export interface AgentPromptMetadataArtifact {
+    agent: string;
+    description?: string;
+    sourceKind: "composer" | "default";
+}
+export interface EvalArtifacts {
+    renderedPrompt?: string;
+    agentMetadata?: AgentPromptMetadataArtifact;
+    toolPolicy?: Record<string, boolean>;
+    promptLength?: number;
+    modelOutput?: string;
+    judgeOutput?: string;
+    trace?: unknown;
+    tokens?: number;
+    cost?: number;
+    baselineDelta?: unknown;
+}
+export interface AssertionResult {
+    evaluatorKind: EvaluatorKind;
+    passed: boolean;
+    score: number;
+    maxScore: number;
+    message: string;
+}
+export interface EvalCaseResult {
+    caseId: string;
+    status: "passed" | "failed" | "error";
+    score: number;
+    normalizedScore: number;
+    maxScore: number;
+    durationMs: number;
+    artifacts: EvalArtifacts;
+    assertionResults: AssertionResult[];
+    errors: string[];
+}
+export interface EvalRunSummary {
+    totalCases: number;
+    passedCases: number;
+    failedCases: number;
+    errorCases: number;
+    totalScore: number;
+    normalizedScore: number;
+    maxScore: number;
+}
+export interface EvalRunResult {
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    suiteId: string;
+    phase: EvalPhase;
+    summary: EvalRunSummary;
+    caseResults: EvalCaseResult[];
+}
+export interface ResolvedTarget {
+    target: EvalTarget;
+    artifacts: EvalArtifacts;
+}
+export interface ExecutionContext {
+    mode: "local" | "ci" | "hosted";
+    directory: string;
+    outputPath?: string;
+}
+export interface RunnerFilters {
+    caseIds?: string[];
+    agents?: string[];
+    tags?: string[];
+}
+export interface RunEvalSuiteOptions {
+    directory: string;
+    suite: string;
+    filters?: RunnerFilters;
+    outputPath?: string;
+    mode?: ExecutionContext["mode"];
+}
+export interface EvalLoadErrorContext {
+    filePath: string;
+    detail: string;
+}
+export interface DeterministicBaselineCase {
+    caseId: string;
+    status: EvalCaseResult["status"];
+    normalizedScore: number;
+    assertionPassed: number;
+    assertionFailed: number;
+    errorCount: number;
+}
+export interface DeterministicBaseline {
+    version: 1;
+    suiteId: string;
+    phase: EvalPhase;
+    generatedAt: string;
+    normalizedScore: number;
+    cases: DeterministicBaselineCase[];
+}
+export interface BaselineComparisonOptions {
+    scoreDropTolerance?: number;
+}
+export interface BaselineComparison {
+    outcome: "no-regression" | "informational-diff" | "regression";
+    regressions: string[];
+    informational: string[];
+}

package/dist/features/task-system/index.d.ts

@@ -0,0 +1,6 @@
+export { createTaskCreateTool, createTaskUpdateTool, createTaskListTool } from "./tools";
+export { TaskStatus, TaskObjectSchema, TaskStatusSchema } from "./types";
+export type { TaskObject, TaskCreateInput, TaskUpdateInput, TaskListInput } from "./types";
+export { getTaskDir, generateTaskId, readTask, writeTask, readAllTasks } from "./storage";
+export { syncTaskToTodo, syncTaskTodoUpdate, syncAllTasksToTodos } from "./todo-sync";
+export type { TodoWriter, TodoInfo } from "./todo-sync";

package/dist/features/task-system/storage.d.ts

@@ -0,0 +1,38 @@
+import { type TaskObject } from "./types";
+/**
+ * Derive the task storage directory for a given project.
+ * Uses the opencode config dir (~/.config/opencode by default) + sanitized project slug.
+ */
+export declare function getTaskDir(directory: string, configDir?: string): string;
+/** Generate a unique task ID */
+export declare function generateTaskId(): string;
+/**
+ * Read and parse a JSON file safely. Returns null for missing, corrupt, or invalid data.
+ */
+export declare function readJsonSafe<T>(filePath: string, schema: {
+    parse: (data: unknown) => T;
+}): T | null;
+/**
+ * Write JSON atomically: write to a temp file then rename.
+ * This prevents partial writes from corrupting the target file.
+ */
+export declare function writeJsonAtomic(filePath: string, data: unknown): void;
+/**
+ * Acquire a file-based lock. Uses exclusive file creation (wx flag).
+ * Returns a release function on success, null on failure.
+ *
+ * Stale locks older than `staleThresholdMs` (default 30s) are automatically broken.
+ */
+export declare function acquireLock(lockPath: string, staleThresholdMs?: number): (() => void) | null;
+/** Ensure a directory exists */
+export declare function ensureDir(dirPath: string): void;
+/** List task files (T-*.json) in the task directory */
+export declare function listTaskFiles(taskDir: string): string[];
+/** Get the file path for a task by ID */
+export declare function getTaskFilePath(taskDir: string, taskId: string): string;
+/** Read a single task from file storage */
+export declare function readTask(taskDir: string, taskId: string): TaskObject | null;
+/** Write a single task to file storage (atomic) */
+export declare function writeTask(taskDir: string, task: TaskObject): void;
+/** Read all tasks from a task directory */
+export declare function readAllTasks(taskDir: string): TaskObject[];

package/dist/features/task-system/todo-sync.d.ts

@@ -0,0 +1,38 @@
+import type { TaskObject } from "./types";
+/** TodoInfo matches the shape expected by OpenCode's todo sidebar */
+export interface TodoInfo {
+    id?: string;
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+    priority?: "high" | "medium" | "low";
+}
+/** TodoWriter interface — abstracts the OpenCode todo write API */
+export interface TodoWriter {
+    read(sessionId: string): Promise<TodoInfo[]>;
+    update(sessionId: string, todos: TodoInfo[]): Promise<void>;
+}
+/**
+ * Map a TaskObject to a TodoInfo for the sidebar.
+ * Returns null for deleted tasks (they should be removed from the sidebar).
+ */
+export declare function syncTaskToTodo(task: TaskObject): TodoInfo | null;
+/**
+ * Check if two todo items match by ID first, then by content as fallback.
+ */
+export declare function todosMatch(a: TodoInfo, b: TodoInfo): boolean;
+/**
+ * Sync a single task to the todo sidebar.
+ * This is the anti-obliteration mechanism:
+ * 1. Read current todos
+ * 2. Filter out the matching item (by ID or content)
+ * 3. Push the updated item (or omit it if deleted)
+ * 4. Write back the full list
+ *
+ * Non-task todos (those not matching any task ID) survive intact.
+ */
+export declare function syncTaskTodoUpdate(writer: TodoWriter | null, sessionId: string, task: TaskObject): Promise<void>;
+/**
+ * Sync all tasks to the todo sidebar, preserving non-task todos.
+ * Used for bulk reconciliation.
+ */
+export declare function syncAllTasksToTodos(writer: TodoWriter | null, sessionId: string, tasks: TaskObject[]): Promise<void>;

package/dist/features/task-system/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { createTaskCreateTool } from "./task-create";
+export { createTaskUpdateTool } from "./task-update";
+export { createTaskListTool } from "./task-list";

package/dist/features/task-system/tools/task-create.d.ts

@@ -0,0 +1,9 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type TodoWriter } from "../todo-sync";
+declare const TASK_ID_PATTERN: RegExp;
+export declare function createTaskCreateTool(options: {
+    directory: string;
+    configDir?: string;
+    todoWriter?: TodoWriter | null;
+}): ToolDefinition;
+export { TASK_ID_PATTERN };

package/dist/features/task-system/tools/task-list.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export declare function createTaskListTool(options: {
+    directory: string;
+    configDir?: string;
+}): ToolDefinition;

package/dist/features/task-system/tools/task-update.d.ts

@@ -0,0 +1,7 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type TodoWriter } from "../todo-sync";
+export declare function createTaskUpdateTool(options: {
+    directory: string;
+    configDir?: string;
+    todoWriter?: TodoWriter | null;
+}): ToolDefinition;

package/dist/features/task-system/types.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+/** Task status values */
+export declare const TaskStatus: {
+    readonly PENDING: "pending";
+    readonly IN_PROGRESS: "in_progress";
+    readonly COMPLETED: "completed";
+    readonly DELETED: "deleted";
+};
+export type TaskStatus = (typeof TaskStatus)[keyof typeof TaskStatus];
+export declare const TaskStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    completed: "completed";
+    in_progress: "in_progress";
+    deleted: "deleted";
+}>;
+/**
+ * Core task object — simplified from OmO's schema.
+ * Drops: activeForm, owner, repoURL, parentID (per design decision D4).
+ */
+export declare const TaskObjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+        deleted: "deleted";
+    }>;
+    threadID: z.ZodString;
+    blocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskObject = z.infer<typeof TaskObjectSchema>;
+/** Input schema for task_create tool */
+export declare const TaskCreateInputSchema: z.ZodObject<{
+    subject: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskCreateInput = z.infer<typeof TaskCreateInputSchema>;
+/** Input schema for task_update tool */
+export declare const TaskUpdateInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+        deleted: "deleted";
+    }>>;
+    addBlocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    addBlockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskUpdateInput = z.infer<typeof TaskUpdateInputSchema>;
+/** Input schema for task_list tool (no args needed for PoC) */
+export declare const TaskListInputSchema: z.ZodObject<{}, z.core.$strip>;
+export type TaskListInput = z.infer<typeof TaskListInputSchema>;