@a4hgehad/weave-mcp 0.8.6 → 0.8.7

package/dist/features/workflow/constants.d.ts

@@ -0,0 +1,12 @@
+/** Root directory for Weave state and plans */
+export { WEAVE_DIR } from "../work-state/constants";
+/** Directory under .weave/ for workflow instance state */
+export declare const WORKFLOWS_STATE_DIR = ".weave/workflows";
+/** File name for individual instance state */
+export declare const INSTANCE_STATE_FILE = "state.json";
+/** Pointer file tracking the currently active workflow instance */
+export declare const ACTIVE_INSTANCE_FILE = "active-instance.json";
+/** Project-level directory for workflow definitions */
+export declare const WORKFLOWS_DIR_PROJECT = ".opencode/workflows";
+/** User-level directory for workflow definitions (under ~/.config/opencode/) */
+export declare const WORKFLOWS_DIR_USER = "workflows";

package/dist/features/workflow/context.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowInstance, WorkflowDefinition, WorkflowStepDefinition } from "./types";
+/**
+ * Resolve template variables in a string.
+ * Supports: {{instance.goal}}, {{instance.slug}}, {{artifacts.X}}, {{step.name}}, {{step.id}}
+ * Unknown variables are left as-is.
+ */
+export declare function resolveTemplate(template: string, instance: WorkflowInstance, definition: WorkflowDefinition): string;
+/**
+ * Build the workflow context header showing goal, step history, and accumulated artifacts.
+ */
+export declare function buildContextHeader(instance: WorkflowInstance, definition: WorkflowDefinition): string;
+/**
+ * Build the full context-threaded prompt for a step.
+ * Combines: (1) workflow context header, (2) resolved step prompt.
+ */
+export declare function composeStepPrompt(stepDef: WorkflowStepDefinition, instance: WorkflowInstance, definition: WorkflowDefinition): string;

package/dist/features/workflow/discovery.d.ts

@@ -0,0 +1,19 @@
+import type { WorkflowDefinition } from "./types";
+/**
+ * A workflow definition discovered from the filesystem.
+ */
+export interface DiscoveredWorkflow {
+    definition: WorkflowDefinition;
+    path: string;
+    scope: "project" | "user";
+}
+/**
+ * Load and validate a single workflow definition from a JSONC file path.
+ * Returns null if the file can't be read, parsed, or fails validation.
+ */
+export declare function loadWorkflowDefinition(filePath: string): WorkflowDefinition | null;
+/**
+ * Discover all valid workflow definitions from project and user directories.
+ * Project workflows override user workflows with the same name.
+ */
+export declare function discoverWorkflows(directory: string): DiscoveredWorkflow[];

package/dist/features/workflow/engine.d.ts

@@ -0,0 +1,49 @@
+import type { WorkflowDefinition } from "./types";
+import type { CompletionContext } from "./completion";
+/**
+ * An action the engine wants the caller to take.
+ */
+export interface EngineAction {
+    type: "inject_prompt" | "switch_agent" | "pause" | "complete" | "none";
+    /** Context-threaded prompt to inject */
+    prompt?: string;
+    /** Agent to switch to for the next step */
+    agent?: string;
+    reason?: string;
+}
+/**
+ * Start a new workflow instance from a definition and goal.
+ * Creates the instance, sets it as active, and returns the first step's prompt.
+ */
+export declare function startWorkflow(input: {
+    definition: WorkflowDefinition;
+    definitionPath: string;
+    goal: string;
+    sessionId: string;
+    directory: string;
+}): EngineAction;
+/**
+ * Check the current step's completion and advance if complete.
+ * This is called on session.idle events.
+ */
+export declare function checkAndAdvance(input: {
+    directory: string;
+    context: CompletionContext;
+}): EngineAction;
+/**
+ * Pause the active workflow instance.
+ */
+export declare function pauseWorkflow(directory: string, reason?: string): boolean;
+/**
+ * Resume a paused workflow instance.
+ * Returns the current step's context-threaded prompt.
+ */
+export declare function resumeWorkflow(directory: string): EngineAction;
+/**
+ * Skip the current step and advance to the next.
+ */
+export declare function skipStep(directory: string): EngineAction;
+/**
+ * Abort the active workflow instance.
+ */
+export declare function abortWorkflow(directory: string): boolean;

package/dist/features/workflow/hook.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Workflow hook handler: detects /run-workflow commands, parses arguments,
+ * manages workflow instances, and drives step transitions on session.idle.
+ */
+/**
+ * Marker embedded in workflow continuation prompts so the auto-pause guard
+ * in plugin-interface.ts can recognize them and NOT pause coexisting WorkState plans.
+ */
+export declare const WORKFLOW_CONTINUATION_MARKER = "<!-- weave:workflow-continuation -->";
+export interface WorkflowHookResult {
+    /** Context to inject into the prompt (step prompt with workflow context) */
+    contextInjection: string | null;
+    /** Agent to switch to for the current step */
+    switchAgent: string | null;
+}
+/**
+ * Parse /run-workflow arguments into workflow name and optional goal.
+ * Argument format: `<workflow-name> "goal text"` or `<workflow-name>` or empty.
+ */
+export declare function parseWorkflowArgs(args: string): {
+    workflowName: string | null;
+    goal: string | null;
+};
+/**
+ * Handle the /run-workflow command.
+ * Detects the command via <session-context> tag, parses arguments,
+ * and either creates a new instance, resumes an existing one, or lists available definitions.
+ */
+export declare function handleRunWorkflow(input: {
+    promptText: string;
+    sessionId: string;
+    directory: string;
+}): WorkflowHookResult;
+/**
+ * Check workflow continuation on session.idle.
+ * If an active workflow instance exists and the current step's completion condition is met,
+ * advance to the next step and return a continuation prompt.
+ */
+export declare function checkWorkflowContinuation(input: {
+    sessionId: string;
+    directory: string;
+    lastAssistantMessage?: string;
+    lastUserMessage?: string;
+}): {
+    continuationPrompt: string | null;
+    switchAgent: string | null;
+};

package/dist/features/workflow/index.d.ts

@@ -0,0 +1,15 @@
+export type { StepType, CompletionMethod, StepStatus, WorkflowStatus, OnRejectAction, ArtifactRef, StepArtifacts, CompletionConfig, WorkflowStepDefinition, WorkflowDefinition, StepState, WorkflowInstance, ActiveInstancePointer, } from "./types";
+export { WORKFLOWS_STATE_DIR, INSTANCE_STATE_FILE, ACTIVE_INSTANCE_FILE, WORKFLOWS_DIR_PROJECT, WORKFLOWS_DIR_USER, } from "./constants";
+export { generateInstanceId, generateSlug, createWorkflowInstance, readWorkflowInstance, writeWorkflowInstance, readActiveInstance, setActiveInstance, clearActiveInstance, getActiveWorkflowInstance, listInstances, appendInstanceSessionId, } from "./storage";
+export type { DiscoveredWorkflow } from "./discovery";
+export { loadWorkflowDefinition, discoverWorkflows } from "./discovery";
+export { resolveTemplate, buildContextHeader, composeStepPrompt } from "./context";
+export type { CompletionCheckResult, CompletionContext } from "./completion";
+export { checkStepCompletion } from "./completion";
+export type { EngineAction } from "./engine";
+export { startWorkflow, checkAndAdvance, pauseWorkflow, resumeWorkflow, skipStep, abortWorkflow, } from "./engine";
+export { WORKFLOW_CONTINUATION_MARKER } from "./hook";
+export type { WorkflowHookResult } from "./hook";
+export { parseWorkflowArgs, handleRunWorkflow, checkWorkflowContinuation } from "./hook";
+export type { WorkflowCommandResult } from "./commands";
+export { handleWorkflowCommand } from "./commands";

package/dist/features/workflow/schema.d.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+/**
+ * Zod schema for step completion configuration in workflow definitions.
+ */
+export declare const CompletionConfigSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        user_confirm: "user_confirm";
+        plan_created: "plan_created";
+        plan_complete: "plan_complete";
+        review_verdict: "review_verdict";
+        agent_signal: "agent_signal";
+    }>;
+    plan_name: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for artifact references.
+ */
+export declare const ArtifactRefSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod schema for step artifact declarations.
+ */
+export declare const StepArtifactsSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for a workflow step definition.
+ */
+export declare const WorkflowStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        interactive: "interactive";
+        autonomous: "autonomous";
+        gate: "gate";
+    }>;
+    agent: z.ZodString;
+    prompt: z.ZodString;
+    completion: z.ZodObject<{
+        method: z.ZodEnum<{
+            user_confirm: "user_confirm";
+            plan_created: "plan_created";
+            plan_complete: "plan_complete";
+            review_verdict: "review_verdict";
+            agent_signal: "agent_signal";
+        }>;
+        plan_name: z.ZodOptional<z.ZodString>;
+        keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    artifacts: z.ZodOptional<z.ZodObject<{
+        inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    on_reject: z.ZodOptional<z.ZodEnum<{
+        pause: "pause";
+        fail: "fail";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for a complete workflow definition file.
+ */
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodNumber;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            interactive: "interactive";
+            autonomous: "autonomous";
+            gate: "gate";
+        }>;
+        agent: z.ZodString;
+        prompt: z.ZodString;
+        completion: z.ZodObject<{
+            method: z.ZodEnum<{
+                user_confirm: "user_confirm";
+                plan_created: "plan_created";
+                plan_complete: "plan_complete";
+                review_verdict: "review_verdict";
+                agent_signal: "agent_signal";
+            }>;
+            plan_name: z.ZodOptional<z.ZodString>;
+            keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        artifacts: z.ZodOptional<z.ZodObject<{
+            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        on_reject: z.ZodOptional<z.ZodEnum<{
+            pause: "pause";
+            fail: "fail";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/features/workflow/storage.d.ts

@@ -0,0 +1,51 @@
+import type { WorkflowDefinition, WorkflowInstance, ActiveInstancePointer } from "./types";
+/**
+ * Generate a unique instance ID.
+ * Format: wf_{8 random hex chars} (e.g., "wf_a1b2c3d4").
+ */
+export declare function generateInstanceId(): string;
+/**
+ * Generate a URL-safe slug from a goal string.
+ * Lowercase, spaces to hyphens, strip non-alphanumeric, truncate to 50 chars.
+ */
+export declare function generateSlug(goal: string): string;
+/**
+ * Create a fresh WorkflowInstance for a definition + goal.
+ */
+export declare function createWorkflowInstance(definition: WorkflowDefinition, definitionPath: string, goal: string, sessionId: string): WorkflowInstance;
+/**
+ * Read a workflow instance by ID. Returns null if not found or invalid.
+ */
+export declare function readWorkflowInstance(directory: string, instanceId: string): WorkflowInstance | null;
+/**
+ * Write a workflow instance to its state directory.
+ * Creates directories as needed.
+ */
+export declare function writeWorkflowInstance(directory: string, instance: WorkflowInstance): boolean;
+/**
+ * Read the active instance pointer. Returns null if no active instance.
+ */
+export declare function readActiveInstance(directory: string): ActiveInstancePointer | null;
+/**
+ * Set the active instance pointer.
+ */
+export declare function setActiveInstance(directory: string, instanceId: string): boolean;
+/**
+ * Clear the active instance pointer (without deleting the instance).
+ */
+export declare function clearActiveInstance(directory: string): boolean;
+/**
+ * Get the active workflow instance (resolves pointer -> reads instance).
+ * Returns null if no active instance or instance not found.
+ */
+export declare function getActiveWorkflowInstance(directory: string): WorkflowInstance | null;
+/**
+ * List all instance IDs (for status/history commands).
+ * Returns IDs sorted alphabetically.
+ */
+export declare function listInstances(directory: string): string[];
+/**
+ * Append a session ID to an instance's session_ids.
+ * Returns the updated instance, or null if the instance doesn't exist.
+ */
+export declare function appendInstanceSessionId(directory: string, instanceId: string, sessionId: string): WorkflowInstance | null;

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

@@ -0,0 +1,142 @@
+/**
+ * Step execution types: interactive (needs user input), autonomous (runs without user),
+ * gate (requires APPROVE/REJECT verdict).
+ */
+export type StepType = "interactive" | "autonomous" | "gate";
+/**
+ * How a step's completion is detected.
+ */
+export type CompletionMethod = "user_confirm" | "plan_created" | "plan_complete" | "review_verdict" | "agent_signal";
+/**
+ * Per-step status in a workflow instance.
+ */
+export type StepStatus = "pending" | "active" | "awaiting_user" | "completed" | "failed" | "skipped";
+/**
+ * Instance-level workflow status.
+ */
+export type WorkflowStatus = "running" | "paused" | "completed" | "failed" | "cancelled";
+/**
+ * What happens when a gate step rejects.
+ */
+export type OnRejectAction = "pause" | "fail";
+/**
+ * Reference to an artifact that a step consumes or produces.
+ */
+export interface ArtifactRef {
+    name: string;
+    description?: string;
+}
+/**
+ * Artifact input/output declarations for a step.
+ */
+export interface StepArtifacts {
+    inputs?: ArtifactRef[];
+    outputs?: ArtifactRef[];
+}
+/**
+ * Configuration for how a step's completion is detected.
+ */
+export interface CompletionConfig {
+    method: CompletionMethod;
+    /** For plan_created/plan_complete: the plan name to check */
+    plan_name?: string;
+    /** For user_confirm: custom keywords to detect */
+    keywords?: string[];
+}
+/**
+ * A single step in a workflow definition (template).
+ */
+export interface WorkflowStepDefinition {
+    /** Unique step ID within the workflow (e.g., "gather", "plan-review") */
+    id: string;
+    /** Human-readable step name */
+    name: string;
+    /** Step execution type */
+    type: StepType;
+    /** Agent to activate for this step */
+    agent: string;
+    /** Prompt template with {{instance.goal}}, {{artifacts.X}} variables */
+    prompt: string;
+    /** How to detect step completion */
+    completion: CompletionConfig;
+    /** Artifact declarations */
+    artifacts?: StepArtifacts;
+    /** For gate steps: what to do on reject */
+    on_reject?: OnRejectAction;
+}
+/**
+ * A workflow definition (reusable template).
+ * Stored as JSONC in .opencode/workflows/ or ~/.config/opencode/workflows/.
+ */
+export interface WorkflowDefinition {
+    /** Workflow name matching the filename (e.g., "secure-feature") */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Schema version for future migration */
+    version: number;
+    /** Ordered list of steps */
+    steps: WorkflowStepDefinition[];
+}
+/**
+ * Per-step state in a workflow instance.
+ */
+export interface StepState {
+    /** Step ID matching the definition */
+    id: string;
+    /** Current step status */
+    status: StepStatus;
+    /** ISO timestamp when the step became active */
+    started_at?: string;
+    /** ISO timestamp when the step completed/failed/skipped */
+    completed_at?: string;
+    /** For gate steps: the verdict */
+    verdict?: "approve" | "reject";
+    /** Error message if failed */
+    error?: string;
+    /** Artifacts produced by this step */
+    artifacts?: Record<string, string>;
+    /** Summary of what this step produced (for context threading) */
+    summary?: string;
+}
+/**
+ * A workflow instance — a specific execution of a workflow definition,
+ * bound to a user goal with accumulated artifacts and step states.
+ */
+export interface WorkflowInstance {
+    /** Unique instance ID (e.g., "wf_a1b2c3d4") */
+    instance_id: string;
+    /** ID of the workflow definition (matches definition name) */
+    definition_id: string;
+    /** Human-readable workflow name */
+    definition_name: string;
+    /** Path to the workflow definition file */
+    definition_path: string;
+    /** The user's goal — what they're trying to accomplish */
+    goal: string;
+    /** URL-safe slug derived from the goal (for plan filenames, etc.) */
+    slug: string;
+    /** Current workflow-level status */
+    status: WorkflowStatus;
+    /** ISO timestamp when the instance was created */
+    started_at: string;
+    /** ISO timestamp when the instance completed/failed/cancelled */
+    ended_at?: string;
+    /** Session IDs that have participated in this instance */
+    session_ids: string[];
+    /** ID of the currently active step */
+    current_step_id: string;
+    /** Per-step state */
+    steps: Record<string, StepState>;
+    /** Accumulated artifacts from completed steps (name -> value) */
+    artifacts: Record<string, string>;
+    /** Why the workflow is paused (if paused) */
+    pause_reason?: string;
+}
+/**
+ * Pointer file content — tracks which instance is currently active.
+ * Stored at .weave/workflows/active-instance.json.
+ */
+export interface ActiveInstancePointer {
+    instance_id: string;
+}

package/dist/hooks/context-window-monitor.d.ts

@@ -0,0 +1,19 @@
+export interface ContextWindowState {
+    usedTokens: number;
+    maxTokens: number;
+    sessionId: string;
+}
+export interface ContextWindowThresholds {
+    warningPct: number;
+    criticalPct: number;
+}
+export type ContextWindowAction = "none" | "warn" | "recover";
+export interface ContextWindowCheckResult {
+    action: ContextWindowAction;
+    usagePct: number;
+    message?: string;
+}
+export declare function checkContextWindow(state: ContextWindowState, thresholds?: ContextWindowThresholds): ContextWindowCheckResult;
+export declare function createContextWindowMonitor(thresholds?: ContextWindowThresholds): {
+    check: (state: ContextWindowState) => ContextWindowCheckResult;
+};

package/dist/hooks/create-hooks.d.ts

@@ -0,0 +1,40 @@
+import type { WeaveConfig } from "../config/schema";
+import { checkContextWindow } from "./context-window-monitor";
+import { getRulesForFile, shouldInjectRules } from "./rules-injector";
+import { shouldApplyVariant, markApplied, markSessionCreated, clearSession } from "./first-message-variant";
+import { processMessageForKeywords } from "./keyword-detector";
+import { checkPatternWrite } from "./pattern-md-only";
+import { buildVerificationReminder } from "./verification-reminder";
+export type CreatedHooks = ReturnType<typeof createHooks>;
+export declare function createHooks(args: {
+    pluginConfig: WeaveConfig;
+    isHookEnabled: (hookName: string) => boolean;
+    directory: string;
+    analyticsEnabled?: boolean;
+}): {
+    checkContextWindow: ((state: Parameters<typeof checkContextWindow>[0]) => import("./context-window-monitor").ContextWindowCheckResult) | null;
+    writeGuard: {
+        trackRead: (filePath: string) => void;
+        checkWrite: (filePath: string) => import("./write-existing-file-guard").WriteGuardCheckResult;
+    } | null;
+    shouldInjectRules: typeof shouldInjectRules | null;
+    getRulesForFile: typeof getRulesForFile | null;
+    firstMessageVariant: {
+        shouldApplyVariant: typeof shouldApplyVariant;
+        markApplied: typeof markApplied;
+        markSessionCreated: typeof markSessionCreated;
+        clearSession: typeof clearSession;
+    } | null;
+    processMessageForKeywords: typeof processMessageForKeywords | null;
+    patternMdOnly: typeof checkPatternWrite | null;
+    startWork: ((promptText: string, sessionId: string) => import("./start-work-hook").StartWorkResult) | null;
+    workContinuation: ((sessionId: string) => import("./work-continuation").ContinuationResult) | null;
+    workflowStart: ((promptText: string, sessionId: string) => import("../features/workflow").WorkflowHookResult) | null;
+    workflowContinuation: ((sessionId: string, lastAssistantMessage?: string, lastUserMessage?: string) => {
+        continuationPrompt: string | null;
+        switchAgent: string | null;
+    }) | null;
+    workflowCommand: ((message: string) => import("../features/workflow").WorkflowCommandResult) | null;
+    verificationReminder: typeof buildVerificationReminder | null;
+    analyticsEnabled: boolean;
+};

package/dist/hooks/first-message-variant.d.ts

@@ -0,0 +1,5 @@
+export declare function markSessionCreated(sessionId: string): void;
+export declare function markApplied(sessionId: string): void;
+export declare function shouldApplyVariant(sessionId: string): boolean;
+export declare function clearSession(sessionId: string): void;
+export declare function clearAll(): void;

package/dist/hooks/index.d.ts

@@ -0,0 +1,14 @@
+export { createHooks } from "./create-hooks";
+export type { CreatedHooks } from "./create-hooks";
+export { checkContextWindow, createContextWindowMonitor } from "./context-window-monitor";
+export type { ContextWindowState, ContextWindowThresholds, ContextWindowCheckResult, ContextWindowAction, } from "./context-window-monitor";
+export { createWriteGuard, createWriteGuardState, trackFileRead, checkWriteAllowed, } from "./write-existing-file-guard";
+export type { WriteGuardState, WriteGuardCheckResult } from "./write-existing-file-guard";
+export { shouldInjectRules, getRulesForFile, buildRulesInjection, getDirectoryFromFilePath, findRulesFile, loadRulesForDirectory, } from "./rules-injector";
+export { shouldApplyVariant, markApplied, markSessionCreated, clearSession, clearAll, } from "./first-message-variant";
+export { detectKeywords, buildKeywordInjection, processMessageForKeywords, DEFAULT_KEYWORD_ACTIONS, } from "./keyword-detector";
+export type { KeywordAction } from "./keyword-detector";
+export { buildVerificationReminder } from "./verification-reminder";
+export type { VerificationInput, VerificationResult } from "./verification-reminder";
+export { setContextLimit, updateUsage, getState, clearSession as clearTokenSession, clear as clearAllTokenState, } from "./session-token-state";
+export type { SessionTokenEntry } from "./session-token-state";

package/dist/hooks/keyword-detector.d.ts

@@ -0,0 +1,8 @@
+export interface KeywordAction {
+    keyword: string;
+    injection: string;
+}
+export declare const DEFAULT_KEYWORD_ACTIONS: KeywordAction[];
+export declare function detectKeywords(message: string, actions?: KeywordAction[]): KeywordAction[];
+export declare function buildKeywordInjection(detected: KeywordAction[]): string | undefined;
+export declare function processMessageForKeywords(message: string, sessionId: string, actions?: KeywordAction[]): string | undefined;

package/dist/hooks/pattern-md-only.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Guard hook that prevents Pattern agent from writing non-.md files
+ * or writing outside the .weave/ directory.
+ */
+export interface PatternWriteCheckResult {
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * Check whether a write/edit operation should be allowed for the given agent.
+ * Only blocks writes from the "pattern" agent to non-.md files or files outside .weave/.
+ */
+export declare function checkPatternWrite(agentName: string, toolName: string, filePath: string): PatternWriteCheckResult;

package/dist/hooks/rules-injector.d.ts

@@ -0,0 +1,6 @@
+export declare function findRulesFile(directory: string): string | undefined;
+export declare function loadRulesForDirectory(directory: string): string | undefined;
+export declare function shouldInjectRules(toolName: string): boolean;
+export declare function getDirectoryFromFilePath(filePath: string): string;
+export declare function buildRulesInjection(rulesContent: string, directory: string): string;
+export declare function getRulesForFile(filePath: string): string | undefined;

package/dist/hooks/session-token-state.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Per-session token state tracker.
+ *
+ * Bridges the gap between:
+ * - `chat.params` hook → provides model context limit (maxTokens)
+ * - `message.updated` event → provides latest input token usage (usedTokens)
+ *
+ * Uses an in-memory Map keyed by sessionId. State resets on plugin restart,
+ * which is acceptable — data rebuilds on the next `chat.params` + `message.updated` pair.
+ */
+export interface SessionTokenEntry {
+    maxTokens: number;
+    usedTokens: number;
+}
+/**
+ * Store the model's context limit for a session.
+ * Called from the `chat.params` hook when a session starts.
+ * Does NOT overwrite existing `usedTokens`.
+ */
+export declare function setContextLimit(sessionId: string, maxTokens: number): void;
+/**
+ * Update the latest input token usage for a session.
+ * Called from `message.updated` events with AssistantMessage tokens.
+ * Stores the latest value — NOT cumulative across messages.
+ * Does NOT overwrite existing `maxTokens`.
+ * Only updates when inputTokens > 0 (guards against partial streaming updates).
+ */
+export declare function updateUsage(sessionId: string, inputTokens: number): void;
+/**
+ * Get the current token state for a session.
+ * Returns undefined if the session is unknown.
+ */
+export declare function getState(sessionId: string): SessionTokenEntry | undefined;
+/**
+ * Remove a session from the tracker.
+ * Called on `session.deleted` events.
+ */
+export declare function clearSession(sessionId: string): void;
+/**
+ * Clear all session state. Used in tests only.
+ */
+export declare function clear(): void;

package/dist/hooks/start-work-hook.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Start-work hook: detects the /start-work command, resolves the target plan,
+ * creates/updates work state, and returns context for injection into the prompt.
+ */
+import type { ValidationResult } from "../features/work-state";
+export interface StartWorkInput {
+    promptText: string;
+    sessionId: string;
+    directory: string;
+}
+export interface StartWorkResult {
+    /** Context to inject into the prompt (plan path, progress, instructions) */
+    contextInjection: string | null;
+    /** Agent to switch to (always "tapestry" when command is detected) */
+    switchAgent: string | null;
+}
+/**
+ * Handle the /start-work command.
+ * Returns null contextInjection if this message is not a /start-work command.
+ */
+export declare function handleStartWork(input: StartWorkInput): StartWorkResult;
+/**
+ * Format validation errors and warnings as a markdown string.
+ */
+export declare function formatValidationResults(result: ValidationResult): string;