diff options
Diffstat (limited to 'makima')
39 files changed, 9115 insertions, 4153 deletions
diff --git a/makima/frontend/src/components/NavStrip.tsx b/makima/frontend/src/components/NavStrip.tsx index 4f6cf32..ece07e4 100644 --- a/makima/frontend/src/components/NavStrip.tsx +++ b/makima/frontend/src/components/NavStrip.tsx @@ -10,6 +10,7 @@ interface NavLink { const NAV_LINKS: NavLink[] = [ { label: "Listen", href: "/listen" }, + { label: "Directives", href: "/directives", requiresAuth: true }, { label: "Chains", href: "/chains", requiresAuth: true }, { label: "Contracts", href: "/contracts", requiresAuth: true }, { label: "Board", href: "/workflow", requiresAuth: true }, diff --git a/makima/frontend/src/hooks/useDirectives.ts b/makima/frontend/src/hooks/useDirectives.ts new file mode 100644 index 0000000..6e1654f --- /dev/null +++ b/makima/frontend/src/hooks/useDirectives.ts @@ -0,0 +1,298 @@ +import { useState, useCallback, useEffect, useRef } from "react"; +import { + listDirectives, + getDirective, + createDirective, + updateDirective, + archiveDirective, + startDirective, + pauseDirective, + resumeDirective, + stopDirective, + getDirectiveGraph, + subscribeToDirectiveEvents, + type DirectiveSummary, + type DirectiveWithProgress, + type DirectiveGraphResponse, + type DirectiveStatus, + type DirectiveEvent, + type CreateDirectiveRequest, + type UpdateDirectiveRequest, + type StartDirectiveResponse, +} from "../lib/api"; + +interface UseDirectivesResult { + directives: DirectiveSummary[]; + loading: boolean; + error: string | null; + refresh: () => Promise<void>; + createNewDirective: (req: CreateDirectiveRequest) => Promise<DirectiveWithProgress | null>; + updateExistingDirective: ( + directiveId: string, + req: UpdateDirectiveRequest + ) => Promise<DirectiveWithProgress | null>; + archiveExistingDirective: (directiveId: string) => Promise<boolean>; + getDirectiveById: (directiveId: string) => Promise<DirectiveWithProgress | null>; + getGraph: (directiveId: string) => Promise<DirectiveGraphResponse | null>; + start: (directiveId: string) => Promise<StartDirectiveResponse | null>; + pause: (directiveId: string) => Promise<boolean>; + resume: (directiveId: string) => Promise<boolean>; + stop: (directiveId: string) => Promise<boolean>; +} + +export function useDirectives(statusFilter?: DirectiveStatus): UseDirectivesResult { + const [directives, setDirectives] = useState<DirectiveSummary[]>([]); + const [loading, setLoading] = useState(true); + const [error, setError] = useState<string | null>(null); + + const fetchDirectives = useCallback(async () => { + setLoading(true); + setError(null); + try { + const response = await listDirectives(statusFilter); + setDirectives(response.directives); + } catch (err) { + console.error("Failed to fetch directives:", err); + setError(err instanceof Error ? err.message : "Failed to fetch directives"); + } finally { + setLoading(false); + } + }, [statusFilter]); + + useEffect(() => { + fetchDirectives(); + }, [fetchDirectives]); + + const createNewDirective = useCallback( + async (req: CreateDirectiveRequest): Promise<DirectiveWithProgress | null> => { + try { + const directive = await createDirective(req); + // Refresh the list + await fetchDirectives(); + // Return the full directive with progress + return await getDirective(directive.id); + } catch (err) { + console.error("Failed to create directive:", err); + setError(err instanceof Error ? err.message : "Failed to create directive"); + return null; + } + }, + [fetchDirectives] + ); + + const updateExistingDirective = useCallback( + async ( + directiveId: string, + req: UpdateDirectiveRequest + ): Promise<DirectiveWithProgress | null> => { + try { + await updateDirective(directiveId, req); + // Refresh the list + await fetchDirectives(); + // Return the updated directive + return await getDirective(directiveId); + } catch (err) { + console.error("Failed to update directive:", err); + setError(err instanceof Error ? err.message : "Failed to update directive"); + return null; + } + }, + [fetchDirectives] + ); + + const archiveExistingDirective = useCallback( + async (directiveId: string): Promise<boolean> => { + try { + await archiveDirective(directiveId); + // Refresh the list + await fetchDirectives(); + return true; + } catch (err) { + console.error("Failed to archive directive:", err); + setError(err instanceof Error ? err.message : "Failed to archive directive"); + return false; + } + }, + [fetchDirectives] + ); + + const getDirectiveById = useCallback( + async (directiveId: string): Promise<DirectiveWithProgress | null> => { + try { + return await getDirective(directiveId); + } catch (err) { + console.error("Failed to get directive:", err); + setError(err instanceof Error ? err.message : "Failed to get directive"); + return null; + } + }, + [] + ); + + const getGraph = useCallback( + async (directiveId: string): Promise<DirectiveGraphResponse | null> => { + try { + return await getDirectiveGraph(directiveId); + } catch (err) { + console.error("Failed to get directive graph:", err); + setError(err instanceof Error ? err.message : "Failed to get directive graph"); + return null; + } + }, + [] + ); + + const start = useCallback( + async (directiveId: string): Promise<StartDirectiveResponse | null> => { + try { + const response = await startDirective(directiveId); + await fetchDirectives(); + return response; + } catch (err) { + console.error("Failed to start directive:", err); + setError(err instanceof Error ? err.message : "Failed to start directive"); + return null; + } + }, + [fetchDirectives] + ); + + const pause = useCallback( + async (directiveId: string): Promise<boolean> => { + try { + await pauseDirective(directiveId); + await fetchDirectives(); + return true; + } catch (err) { + console.error("Failed to pause directive:", err); + setError(err instanceof Error ? err.message : "Failed to pause directive"); + return false; + } + }, + [fetchDirectives] + ); + + const resume = useCallback( + async (directiveId: string): Promise<boolean> => { + try { + await resumeDirective(directiveId); + await fetchDirectives(); + return true; + } catch (err) { + console.error("Failed to resume directive:", err); + setError(err instanceof Error ? err.message : "Failed to resume directive"); + return false; + } + }, + [fetchDirectives] + ); + + const stop = useCallback( + async (directiveId: string): Promise<boolean> => { + try { + await stopDirective(directiveId); + await fetchDirectives(); + return true; + } catch (err) { + console.error("Failed to stop directive:", err); + setError(err instanceof Error ? err.message : "Failed to stop directive"); + return false; + } + }, + [fetchDirectives] + ); + + return { + directives, + loading, + error, + refresh: fetchDirectives, + createNewDirective, + updateExistingDirective, + archiveExistingDirective, + getDirectiveById, + getGraph, + start, + pause, + resume, + stop, + }; +} + +/** Hook for subscribing to real-time directive events via SSE */ +export function useDirectiveEventSubscription( + directiveId: string | null, + onEvent?: (event: DirectiveEvent) => void +): { + events: DirectiveEvent[]; + isConnected: boolean; + error: string | null; +} { + const [events, setEvents] = useState<DirectiveEvent[]>([]); + const [isConnected, setIsConnected] = useState(false); + const [error, setError] = useState<string | null>(null); + const cleanupRef = useRef<(() => void) | null>(null); + + useEffect(() => { + // Clean up any existing subscription + if (cleanupRef.current) { + cleanupRef.current(); + cleanupRef.current = null; + } + + if (!directiveId) { + setIsConnected(false); + setEvents([]); + return; + } + + // Subscribe to events + let mounted = true; + + const setupSubscription = async () => { + try { + const cleanup = await subscribeToDirectiveEvents( + directiveId, + (event) => { + if (mounted) { + setEvents((prev) => [...prev, event]); + onEvent?.(event); + } + }, + (err) => { + if (mounted) { + setError(err.message); + setIsConnected(false); + } + } + ); + + if (mounted) { + cleanupRef.current = cleanup; + setIsConnected(true); + setError(null); + } else { + // Component unmounted during setup, clean up immediately + cleanup(); + } + } catch (err) { + if (mounted) { + setError(err instanceof Error ? err.message : "Failed to subscribe to events"); + setIsConnected(false); + } + } + }; + + setupSubscription(); + + return () => { + mounted = false; + if (cleanupRef.current) { + cleanupRef.current(); + cleanupRef.current = null; + } + }; + }, [directiveId, onEvent]); + + return { events, isConnected, error }; +} diff --git a/makima/frontend/src/lib/api.ts b/makima/frontend/src/lib/api.ts index 2f4ee62..80a43eb 100644 --- a/makima/frontend/src/lib/api.ts +++ b/makima/frontend/src/lib/api.ts @@ -3527,3 +3527,761 @@ export async function setChainRepositoryPrimary( } return res.json(); } + +// ============================================================================= +// Directive Types and API +// ============================================================================= + +/** Directive status */ +export type DirectiveStatus = + | "draft" + | "planning" + | "active" + | "paused" + | "completed" + | "archived" + | "failed"; + +/** Autonomy level */ +export type AutonomyLevel = "full_auto" | "guardrails" | "manual"; + +/** Confidence level (traffic light) */ +export type ConfidenceLevel = "green" | "yellow" | "red"; + +/** Step status */ +export type StepStatus = + | "pending" + | "ready" + | "running" + | "evaluating" + | "passed" + | "failed" + | "rework" + | "skipped" + | "blocked"; + +/** Evaluation type */ +export type EvaluationType = "programmatic" | "llm" | "composite" | "manual"; + +/** Directive summary for list view */ +export interface DirectiveSummary { + id: string; + title: string; + goal: string; + status: DirectiveStatus; + autonomyLevel: AutonomyLevel; + repositoryUrl: string | null; + currentChainId: string | null; + currentChainGeneration: number | null; + totalSteps: number; + completedSteps: number; + failedSteps: number; + currentConfidence: number | null; + totalCostUsd: number; + createdAt: string; + updatedAt: string; +} + +/** Full directive */ +export interface Directive { + id: string; + ownerId: string; + title: string; + goal: string; + status: DirectiveStatus; + autonomyLevel: AutonomyLevel; + repositoryUrl: string | null; + localPath: string | null; + requirements: unknown | null; + acceptanceCriteria: unknown | null; + constraints: unknown | null; + confidenceThresholdGreen: number; + confidenceThresholdYellow: number; + maxReworkCycles: number; + maxTotalCostUsd: number | null; + maxWallTimeMinutes: number | null; + maxChainRegenerations: number; + totalCostUsd: number; + currentChainId: string | null; + version: number; + createdAt: string; + updatedAt: string; + startedAt: string | null; + completedAt: string | null; +} + +/** Directive chain */ +export interface DirectiveChain { + id: string; + directiveId: string; + generation: number; + name: string; + description: string | null; + rationale: string | null; + planningModel: string | null; + status: string; + totalSteps: number; + completedSteps: number; + failedSteps: number; + currentConfidence: number | null; + startedAt: string | null; + completedAt: string | null; + version: number; + createdAt: string; + updatedAt: string; +} + +/** Chain step */ +export interface ChainStep { + id: string; + chainId: string; + name: string; + description: string | null; + stepType: string; + contractType: string; + initialPhase: string | null; + taskPlan: string | null; + phases: string[]; + dependsOn: string[]; + parallelGroup: string | null; + requirementIds: string[]; + acceptanceCriteriaIds: string[]; + verifierConfig: unknown; + status: StepStatus; + contractId: string | null; + supervisorTaskId: string | null; + confidenceScore: number | null; + confidenceLevel: ConfidenceLevel | null; + evaluationCount: number; + reworkCount: number; + lastEvaluationId: string | null; + editorX: number | null; + editorY: number | null; + startedAt: string | null; + completedAt: string | null; + createdAt: string; + updatedAt: string; +} + +/** Directive with progress info */ +export interface DirectiveWithProgress extends Directive { + chain: DirectiveChain | null; + steps: ChainStep[]; + recentEvents: DirectiveEvent[]; + pendingApprovals: DirectiveApproval[]; +} + +/** Directive evaluation */ +export interface DirectiveEvaluation { + id: string; + directiveId: string; + chainId: string | null; + stepId: string | null; + evaluationType: EvaluationType; + passed: boolean; + overallScore: number; + confidenceLevel: ConfidenceLevel; + programmaticResults: unknown | null; + llmResults: unknown | null; + compositeBreakdown: unknown | null; + feedback: string | null; + reworkInstructions: string | null; + verifierIds: string[]; + evaluatedBy: string | null; + createdAt: string; +} + +/** Directive event */ +export interface DirectiveEvent { + id: string; + directiveId: string; + chainId: string | null; + stepId: string | null; + eventType: string; + severity: string; + eventData: unknown | null; + actorType: string; + actorId: string | null; + createdAt: string; +} + +/** Directive approval */ +export interface DirectiveApproval { + id: string; + directiveId: string; + chainId: string | null; + stepId: string | null; + approvalType: string; + description: string; + context: unknown | null; + urgency: string; + status: string; + requestedAt: string; + resolvedAt: string | null; + resolvedBy: string | null; + response: string | null; +} + +/** Directive verifier */ +export interface DirectiveVerifier { + id: string; + directiveId: string; + name: string; + verifierType: string; + command: string | null; + workingDirectory: string | null; + timeoutSeconds: number; + environment: unknown; + autoDetect: boolean; + detectFiles: string[]; + weight: number; + required: boolean; + enabled: boolean; + lastRunAt: string | null; + lastResult: unknown | null; + createdAt: string; + updatedAt: string; +} + +/** Directive graph node */ +export interface DirectiveGraphNode { + id: string; + name: string; + stepType: string; + status: StepStatus; + confidenceScore: number | null; + confidenceLevel: ConfidenceLevel | null; + contractId: string | null; + editorX: number | null; + editorY: number | null; +} + +/** Directive graph edge */ +export interface DirectiveGraphEdge { + source: string; + target: string; +} + +/** Directive graph response */ +export interface DirectiveGraphResponse { + chainId: string; + directiveId: string; + nodes: DirectiveGraphNode[]; + edges: DirectiveGraphEdge[]; +} + +/** Create directive request */ +export interface CreateDirectiveRequest { + goal: string; + repositoryUrl?: string; + localPath?: string; + autonomyLevel?: AutonomyLevel; + confidenceThresholdGreen?: number; + confidenceThresholdYellow?: number; + maxReworkCycles?: number; + maxTotalCostUsd?: number; + maxWallTimeMinutes?: number; +} + +/** Update directive request */ +export interface UpdateDirectiveRequest { + title?: string; + goal?: string; + requirements?: unknown; + acceptanceCriteria?: unknown; + constraints?: unknown; + autonomyLevel?: AutonomyLevel; + confidenceThresholdGreen?: number; + confidenceThresholdYellow?: number; + maxReworkCycles?: number; + maxTotalCostUsd?: number; + maxWallTimeMinutes?: number; + version?: number; +} + +/** Add step request */ +export interface AddStepRequest { + name: string; + description?: string; + stepType?: string; + contractType?: string; + initialPhase?: string; + taskPlan?: string; + phases?: string[]; + dependsOn?: string[]; + parallelGroup?: string; + requirementIds?: string[]; + acceptanceCriteriaIds?: string[]; + verifierConfig?: unknown; + editorX?: number; + editorY?: number; +} + +/** Update step request */ +export interface UpdateStepRequest { + name?: string; + description?: string; + initialPhase?: string; + taskPlan?: string; + phases?: string[]; + dependsOn?: string[]; + parallelGroup?: string; + requirementIds?: string[]; + acceptanceCriteriaIds?: string[]; + verifierConfig?: unknown; + editorX?: number; + editorY?: number; +} + +/** Create verifier request */ +export interface CreateVerifierRequest { + name: string; + verifierType: string; + command?: string; + workingDirectory?: string; + timeoutSeconds?: number; + weight?: number; + required?: boolean; + enabled?: boolean; +} + +/** Update verifier request */ +export interface UpdateVerifierRequest { + command?: string; + weight?: number; + required?: boolean; + enabled?: boolean; +} + +/** Approval action request */ +export interface ApprovalActionRequest { + response?: string; +} + +/** Start directive response */ +export interface StartDirectiveResponse { + directiveId: string; + chainId: string; + chainGeneration: number; + steps: ChainStep[]; + status: string; +} + +/** Directive list response */ +export interface DirectiveListResponse { + directives: DirectiveSummary[]; + total: number; +} + +// ============================================================================= +// Directive API Functions +// ============================================================================= + +/** List directives */ +export async function listDirectives( + status?: DirectiveStatus, + limit = 50, + offset = 0 +): Promise<DirectiveListResponse> { + const params = new URLSearchParams(); + if (status) params.set("status", status); + params.set("limit", String(limit)); + params.set("offset", String(offset)); + + const res = await authFetch(`${API_BASE}/api/v1/directives?${params}`); + if (!res.ok) { + throw new Error(`Failed to list directives: ${res.statusText}`); + } + return res.json(); +} + +/** Get directive by ID */ +export async function getDirective(directiveId: string): Promise<DirectiveWithProgress> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}`); + if (!res.ok) { + throw new Error(`Failed to get directive: ${res.statusText}`); + } + return res.json(); +} + +/** Create a new directive */ +export async function createDirective(req: CreateDirectiveRequest): Promise<Directive> { + const res = await authFetch(`${API_BASE}/api/v1/directives`, { + method: "POST", + body: JSON.stringify(req), + }); + if (!res.ok) { + const errorText = await res.text(); + throw new Error(`Failed to create directive: ${errorText || res.statusText}`); + } + return res.json(); +} + +/** Update directive */ +export async function updateDirective( + directiveId: string, + req: UpdateDirectiveRequest +): Promise<Directive> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}`, { + method: "PUT", + body: JSON.stringify(req), + }); + if (!res.ok) { + throw new Error(`Failed to update directive: ${res.statusText}`); + } + return res.json(); +} + +/** Archive directive */ +export async function archiveDirective(directiveId: string): Promise<{ archived: boolean }> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}`, { + method: "DELETE", + }); + if (!res.ok) { + throw new Error(`Failed to archive directive: ${res.statusText}`); + } + return res.json(); +} + +/** Start directive */ +export async function startDirective(directiveId: string): Promise<StartDirectiveResponse> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/start`, { + method: "POST", + }); + if (!res.ok) { + throw new Error(`Failed to start directive: ${res.statusText}`); + } + return res.json(); +} + +/** Pause directive */ +export async function pauseDirective(directiveId: string): Promise<Directive> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/pause`, { + method: "POST", + }); + if (!res.ok) { + throw new Error(`Failed to pause directive: ${res.statusText}`); + } + return res.json(); +} + +/** Resume directive */ +export async function resumeDirective(directiveId: string): Promise<Directive> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/resume`, { + method: "POST", + }); + if (!res.ok) { + throw new Error(`Failed to resume directive: ${res.statusText}`); + } + return res.json(); +} + +/** Stop directive */ +export async function stopDirective(directiveId: string): Promise<Directive> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/stop`, { + method: "POST", + }); + if (!res.ok) { + throw new Error(`Failed to stop directive: ${res.statusText}`); + } + return res.json(); +} + +/** Get directive chain */ +export async function getDirectiveChain( + directiveId: string +): Promise<{ chain: DirectiveChain | null; steps: ChainStep[] }> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/chain`); + if (!res.ok) { + throw new Error(`Failed to get directive chain: ${res.statusText}`); + } + return res.json(); +} + +/** Get directive chain graph */ +export async function getDirectiveGraph(directiveId: string): Promise<DirectiveGraphResponse> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/chain/graph`); + if (!res.ok) { + throw new Error(`Failed to get directive graph: ${res.statusText}`); + } + return res.json(); +} + +/** Replan directive chain */ +export async function replanDirectiveChain(directiveId: string): Promise<DirectiveChain> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/chain/replan`, { + method: "POST", + }); + if (!res.ok) { + throw new Error(`Failed to replan directive chain: ${res.statusText}`); + } + return res.json(); +} + +/** Add step to directive chain */ +export async function addDirectiveStep( + directiveId: string, + req: AddStepRequest +): Promise<ChainStep> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/chain/steps`, { + method: "POST", + body: JSON.stringify(req), + }); + if (!res.ok) { + throw new Error(`Failed to add step: ${res.statusText}`); + } + return res.json(); +} + +/** Get step details */ +export async function getDirectiveStep( + directiveId: string, + stepId: string +): Promise<ChainStep> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/steps/${stepId}`); + if (!res.ok) { + throw new Error(`Failed to get step: ${res.statusText}`); + } + return res.json(); +} + +/** Update step */ +export async function updateDirectiveStep( + directiveId: string, + stepId: string, + req: UpdateStepRequest +): Promise<ChainStep> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/chain/steps/${stepId}`, + { + method: "PUT", + body: JSON.stringify(req), + } + ); + if (!res.ok) { + throw new Error(`Failed to update step: ${res.statusText}`); + } + return res.json(); +} + +/** Delete step */ +export async function deleteDirectiveStep( + directiveId: string, + stepId: string +): Promise<{ deleted: boolean }> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/chain/steps/${stepId}`, + { + method: "DELETE", + } + ); + if (!res.ok) { + throw new Error(`Failed to delete step: ${res.statusText}`); + } + return res.json(); +} + +/** Skip step */ +export async function skipDirectiveStep( + directiveId: string, + stepId: string +): Promise<ChainStep> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/steps/${stepId}/skip`, + { + method: "POST", + } + ); + if (!res.ok) { + throw new Error(`Failed to skip step: ${res.statusText}`); + } + return res.json(); +} + +/** List directive evaluations */ +export async function listDirectiveEvaluations( + directiveId: string, + limit = 50 +): Promise<DirectiveEvaluation[]> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/evaluations?limit=${limit}` + ); + if (!res.ok) { + throw new Error(`Failed to list evaluations: ${res.statusText}`); + } + return res.json(); +} + +/** List directive events */ +export async function listDirectiveEvents( + directiveId: string, + limit = 50 +): Promise<DirectiveEvent[]> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/events?limit=${limit}` + ); + if (!res.ok) { + throw new Error(`Failed to list events: ${res.statusText}`); + } + return res.json(); +} + +/** List directive verifiers */ +export async function listDirectiveVerifiers( + directiveId: string +): Promise<DirectiveVerifier[]> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/verifiers`); + if (!res.ok) { + throw new Error(`Failed to list verifiers: ${res.statusText}`); + } + return res.json(); +} + +/** Add verifier */ +export async function addDirectiveVerifier( + directiveId: string, + req: CreateVerifierRequest +): Promise<DirectiveVerifier> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/verifiers`, { + method: "POST", + body: JSON.stringify(req), + }); + if (!res.ok) { + throw new Error(`Failed to add verifier: ${res.statusText}`); + } + return res.json(); +} + +/** Update verifier */ +export async function updateDirectiveVerifier( + directiveId: string, + verifierId: string, + req: UpdateVerifierRequest +): Promise<DirectiveVerifier> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/verifiers/${verifierId}`, + { + method: "PUT", + body: JSON.stringify(req), + } + ); + if (!res.ok) { + throw new Error(`Failed to update verifier: ${res.statusText}`); + } + return res.json(); +} + +/** Auto-detect verifiers */ +export async function autoDetectVerifiers( + directiveId: string +): Promise<DirectiveVerifier[]> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/verifiers/auto-detect`, + { + method: "POST", + } + ); + if (!res.ok) { + throw new Error(`Failed to auto-detect verifiers: ${res.statusText}`); + } + return res.json(); +} + +/** List pending approvals */ +export async function listDirectiveApprovals( + directiveId: string +): Promise<DirectiveApproval[]> { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/approvals`); + if (!res.ok) { + throw new Error(`Failed to list approvals: ${res.statusText}`); + } + return res.json(); +} + +/** Approve request */ +export async function approveDirectiveRequest( + directiveId: string, + approvalId: string, + req?: ApprovalActionRequest +): Promise<DirectiveApproval> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/approvals/${approvalId}/approve`, + { + method: "POST", + body: JSON.stringify(req || {}), + } + ); + if (!res.ok) { + throw new Error(`Failed to approve request: ${res.statusText}`); + } + return res.json(); +} + +/** Deny request */ +export async function denyDirectiveRequest( + directiveId: string, + approvalId: string, + req?: ApprovalActionRequest +): Promise<DirectiveApproval> { + const res = await authFetch( + `${API_BASE}/api/v1/directives/${directiveId}/approvals/${approvalId}/deny`, + { + method: "POST", + body: JSON.stringify(req || {}), + } + ); + if (!res.ok) { + throw new Error(`Failed to deny request: ${res.statusText}`); + } + return res.json(); +} + +/** Subscribe to directive events via SSE */ +export async function subscribeToDirectiveEvents( + directiveId: string, + onEvent: (event: DirectiveEvent) => void, + onError?: (error: Error) => void +): Promise<() => void> { + // Get auth token for the request + let authToken: string | null = null; + if (supabase) { + const { data: { session } } = await supabase.auth.getSession(); + if (session?.access_token) { + authToken = session.access_token; + } + } + + // Build URL with auth token as query param (since EventSource doesn't support headers) + const url = new URL(`${API_BASE}/api/v1/directives/${directiveId}/events/stream`); + if (authToken) { + url.searchParams.set("token", authToken); + } else { + const apiKey = getStoredApiKey(); + if (apiKey) { + url.searchParams.set("api_key", apiKey); + } + } + + // Create EventSource connection + const eventSource = new EventSource(url.toString()); + + eventSource.onmessage = (e) => { + try { + const event = JSON.parse(e.data) as DirectiveEvent; + onEvent(event); + } catch (err) { + console.error("Failed to parse SSE event:", err); + } + }; + + eventSource.onerror = (_e) => { + if (onError) { + onError(new Error("SSE connection error")); + } + }; + + // Return cleanup function + return () => { + eventSource.close(); + }; +} diff --git a/makima/frontend/src/main.tsx b/makima/frontend/src/main.tsx index a7ba1a3..5a1b98e 100644 --- a/makima/frontend/src/main.tsx +++ b/makima/frontend/src/main.tsx @@ -13,6 +13,7 @@ import ListenPage from "./routes/listen"; import FilesPage from "./routes/files"; import ContractsPage from "./routes/contracts"; import ChainsPage from "./routes/chains"; +import DirectivesPage from "./routes/directives"; import WorkflowPage from "./routes/workflow"; import MeshPage from "./routes/mesh"; import HistoryPage from "./routes/history"; @@ -89,6 +90,22 @@ createRoot(document.getElementById("root")!).render( } /> <Route + path="/directives" + element={ + <ProtectedRoute> + <DirectivesPage /> + </ProtectedRoute> + } + /> + <Route + path="/directives/:id" + element={ + <ProtectedRoute> + <DirectivesPage /> + </ProtectedRoute> + } + /> + <Route path="/contracts/:id/files/:fileId" element={ <ProtectedRoute> diff --git a/makima/frontend/src/routes/directives.tsx b/makima/frontend/src/routes/directives.tsx new file mode 100644 index 0000000..51fd57a --- /dev/null +++ b/makima/frontend/src/routes/directives.tsx @@ -0,0 +1,1254 @@ +import { useState, useCallback, useEffect, useMemo } from "react"; +import { useParams, useNavigate } from "react-router"; +import { + ReactFlow, + Edge, + Controls, + Background, + Handle, + Position, + BackgroundVariant, + MarkerType, +} from "@xyflow/react"; +import "@xyflow/react/dist/style.css"; +import { Masthead } from "../components/Masthead"; +import { useDirectives, useDirectiveEventSubscription } from "../hooks/useDirectives"; +import { useAuth } from "../contexts/AuthContext"; +import type { + DirectiveSummary, + DirectiveWithProgress, + DirectiveGraphResponse, + DirectiveGraphNode, + CreateDirectiveRequest, + RepositoryHistoryEntry, + AutonomyLevel, + StepStatus, + ConfidenceLevel, +} from "../lib/api"; +import { getRepositorySuggestions } from "../lib/api"; + +export default function DirectivesPage() { + const { isAuthenticated, isAuthConfigured, isLoading: authLoading } = useAuth(); + const navigate = useNavigate(); + + // Redirect to login if not authenticated (when auth is configured) + useEffect(() => { + if (!authLoading && isAuthConfigured && !isAuthenticated) { + navigate("/login"); + } + }, [authLoading, isAuthConfigured, isAuthenticated, navigate]); + + // Show loading while checking auth + if (authLoading) { + return ( + <div className="relative z-10 min-h-screen flex flex-col bg-[#0a1628]"> + <Masthead showNav /> + <main className="flex-1 flex items-center justify-center"> + <p className="text-[#7788aa] font-mono text-sm">Loading...</p> + </main> + </div> + ); + } + + // Don't render if not authenticated (will redirect) + if (isAuthConfigured && !isAuthenticated) { + return null; + } + + return <DirectivesPageContent />; +} + +function DirectivesPageContent() { + const { id } = useParams<{ id: string }>(); + const navigate = useNavigate(); + const { + directives, + loading, + error, + createNewDirective, + archiveExistingDirective, + getDirectiveById, + getGraph, + start, + pause, + resume, + stop, + } = useDirectives(); + + const [directiveDetail, setDirectiveDetail] = useState<DirectiveWithProgress | null>(null); + const [directiveGraph, setDirectiveGraph] = useState<DirectiveGraphResponse | null>(null); + const [detailLoading, setDetailLoading] = useState(false); + const [isCreating, setIsCreating] = useState(false); + + // Load directive detail when ID changes + useEffect(() => { + if (id) { + setDetailLoading(true); + Promise.all([getDirectiveById(id), getGraph(id).catch(() => null)]).then(([directive, graph]) => { + setDirectiveDetail(directive); + setDirectiveGraph(graph); + setDetailLoading(false); + }); + } else { + setDirectiveDetail(null); + setDirectiveGraph(null); + } + }, [id, getDirectiveById, getGraph]); + + const handleSelect = useCallback( + (directiveId: string) => { + navigate(`/directives/${directiveId}`); + }, + [navigate] + ); + + const handleBack = useCallback(() => { + navigate("/directives"); + }, [navigate]); + + const handleCreate = useCallback(() => { + setIsCreating(true); + }, []); + + const handleCreateSubmit = useCallback( + async (goal: string, repositoryUrl: string | undefined, autonomyLevel: AutonomyLevel) => { + const data: CreateDirectiveRequest = { + goal: goal.trim(), + repositoryUrl: repositoryUrl?.trim() || undefined, + autonomyLevel, + }; + + try { + const result = await createNewDirective(data); + if (result) { + setIsCreating(false); + navigate(`/directives/${result.id}`); + } + } catch (err) { + console.error("Failed to create directive:", err); + } + }, + [createNewDirective, navigate] + ); + + const handleCreateCancel = useCallback(() => { + setIsCreating(false); + }, []); + + const handleArchive = useCallback( + async (directive: DirectiveSummary) => { + if (confirm(`Are you sure you want to archive this directive?`)) { + const success = await archiveExistingDirective(directive.id); + if (success && directive.id === id) { + navigate("/directives"); + } + } + }, + [archiveExistingDirective, id, navigate] + ); + + const handleRefresh = useCallback(async () => { + if (id) { + const [directive, graph] = await Promise.all([ + getDirectiveById(id), + getGraph(id).catch(() => null), + ]); + setDirectiveDetail(directive); + setDirectiveGraph(graph); + } + }, [id, getDirectiveById, getGraph]); + + const handleStart = useCallback(async () => { + if (id) { + await start(id); + handleRefresh(); + } + }, [id, start, handleRefresh]); + + const handlePause = useCallback(async () => { + if (id) { + await pause(id); + handleRefresh(); + } + }, [id, pause, handleRefresh]); + + const handleResume = useCallback(async () => { + if (id) { + await resume(id); + handleRefresh(); + } + }, [id, resume, handleRefresh]); + + const handleStop = useCallback(async () => { + if (id) { + await stop(id); + handleRefresh(); + } + }, [id, stop, handleRefresh]); + + return ( + <div className="relative z-10 min-h-screen flex flex-col bg-[#0a1628]"> + <Masthead showNav /> + <main className="flex-1 flex flex-col p-4 pt-2 gap-4 overflow-hidden"> + {error && ( + <div className="p-3 bg-red-400/10 border border-red-400/30 text-red-400 font-mono text-sm"> + {error} + </div> + )} + + {/* Create directive modal */} + {isCreating && ( + <CreateDirectiveModal + onSubmit={handleCreateSubmit} + onCancel={handleCreateCancel} + /> + )} + + <div className="flex-1 grid grid-cols-[350px_1fr] gap-4 min-h-0"> + {/* Directive list */} + <DirectiveList + directives={directives} + loading={loading} + onSelect={handleSelect} + onCreate={handleCreate} + selectedId={id} + onArchive={handleArchive} + /> + + {/* Directive detail or empty state */} + {directiveDetail ? ( + <DirectiveDetail + directive={directiveDetail} + graph={directiveGraph} + loading={detailLoading} + onBack={handleBack} + onRefresh={handleRefresh} + onStart={handleStart} + onPause={handlePause} + onResume={handleResume} + onStop={handleStop} + /> + ) : ( + <div className="panel h-full flex items-center justify-center"> + <div className="text-center"> + <p className="font-mono text-sm text-[#555] mb-4"> + Select a directive or create a new one + </p> + <button + onClick={handleCreate} + className="px-4 py-2 font-mono text-xs text-[#dbe7ff] bg-[#0f3c78] border border-[#3f6fb3] hover:bg-[#153667] transition-colors uppercase" + > + + New Directive + </button> + </div> + </div> + )} + </div> + </main> + </div> + ); +} + +// ============================================================================= +// Directive List Component +// ============================================================================= + +interface DirectiveListProps { + directives: DirectiveSummary[]; + loading: boolean; + onSelect: (id: string) => void; + onCreate: () => void; + selectedId?: string; + onArchive: (directive: DirectiveSummary) => void; +} + +function DirectiveList({ + directives, + loading, + onSelect, + onCreate, + selectedId, + onArchive, +}: DirectiveListProps) { + const [filter, setFilter] = useState<"all" | "active" | "completed" | "failed">("all"); + + const filteredDirectives = directives.filter((d) => { + if (filter === "all") return true; + if (filter === "active") return ["draft", "planning", "active", "paused"].includes(d.status); + if (filter === "completed") return d.status === "completed"; + if (filter === "failed") return d.status === "failed"; + return true; + }); + + return ( + <div className="panel h-full flex flex-col overflow-hidden"> + <div className="flex items-center justify-between p-3 border-b border-[rgba(117,170,252,0.15)]"> + <h2 className="font-mono text-sm text-[#75aafc] uppercase">Directives</h2> + <button + onClick={onCreate} + className="px-3 py-1 font-mono text-[10px] text-[#dbe7ff] bg-[#0f3c78] border border-[#3f6fb3] hover:bg-[#153667] transition-colors uppercase" + > + + New + </button> + </div> + + {/* Filters */} + <div className="flex gap-1 p-2 border-b border-[rgba(117,170,252,0.1)]"> + {(["all", "active", "completed", "failed"] as const).map((f) => ( + <button + key={f} + onClick={() => setFilter(f)} + className={`px-2 py-1 font-mono text-[10px] uppercase ${ + filter === f + ? "text-[#dbe7ff] bg-[#0f3c78] border border-[#3f6fb3]" + : "text-[#556677] hover:text-[#9bc3ff]" + }`} + > + {f} + </button> + ))} + </div> + + {/* List */} + <div className="flex-1 overflow-y-auto"> + {loading ? ( + <div className="p-4 text-center"> + <p className="font-mono text-xs text-[#556677]">Loading...</p> + </div> + ) : filteredDirectives.length === 0 ? ( + <div className="p-4 text-center"> + <p className="font-mono text-xs text-[#556677]">No directives found</p> + </div> + ) : ( + filteredDirectives.map((d) => ( + <DirectiveListItem + key={d.id} + directive={d} + selected={d.id === selectedId} + onClick={() => onSelect(d.id)} + onArchive={() => onArchive(d)} + /> + )) + )} + </div> + </div> + ); +} + +interface DirectiveListItemProps { + directive: DirectiveSummary; + selected: boolean; + onClick: () => void; + onArchive: () => void; +} + +function DirectiveListItem({ directive, selected, onClick, onArchive }: DirectiveListItemProps) { + const progress = directive.totalSteps > 0 + ? Math.round((directive.completedSteps / directive.totalSteps) * 100) + : 0; + + const statusColor = { + draft: "text-[#556677]", + planning: "text-yellow-400", + active: "text-green-400", + paused: "text-yellow-400", + completed: "text-[#75aafc]", + archived: "text-[#556677]", + failed: "text-red-400", + }[directive.status] || "text-[#556677]"; + + const confidenceColor = { + green: "bg-green-500", + yellow: "bg-yellow-500", + red: "bg-red-500", + }[directive.currentConfidence !== null && directive.currentConfidence >= 0.8 + ? "green" + : directive.currentConfidence !== null && directive.currentConfidence >= 0.5 + ? "yellow" + : "red"] || "bg-[#556677]"; + + return ( + <div + onClick={onClick} + className={`p-3 cursor-pointer border-b border-[rgba(117,170,252,0.1)] hover:bg-[rgba(117,170,252,0.05)] ${ + selected ? "bg-[rgba(117,170,252,0.1)]" : "" + }`} + > + <div className="flex items-start justify-between gap-2"> + <div className="flex-1 min-w-0"> + <div className="font-mono text-sm text-[#dbe7ff] truncate"> + {directive.title || directive.goal.slice(0, 50)} + </div> + <div className="flex items-center gap-2 mt-1"> + <span className={`font-mono text-[10px] uppercase ${statusColor}`}> + {directive.status} + </span> + <span className="font-mono text-[10px] text-[#556677]"> + {directive.completedSteps}/{directive.totalSteps} steps + </span> + </div> + </div> + <div className="flex flex-col items-end gap-1"> + {directive.currentConfidence !== null && ( + <div className={`w-2 h-2 rounded-full ${confidenceColor}`} title={`Confidence: ${Math.round(directive.currentConfidence * 100)}%`} /> + )} + <button + onClick={(e) => { + e.stopPropagation(); + onArchive(); + }} + className="font-mono text-[10px] text-[#556677] hover:text-red-400" + > + Archive + </button> + </div> + </div> + + {/* Progress bar */} + {directive.totalSteps > 0 && ( + <div className="mt-2 h-1 bg-[rgba(117,170,252,0.1)] overflow-hidden"> + <div + className="h-full bg-[#75aafc] transition-all duration-300" + style={{ width: `${progress}%` }} + /> + </div> + )} + </div> + ); +} + +// ============================================================================= +// Directive Detail Component +// ============================================================================= + +interface DirectiveDetailProps { + directive: DirectiveWithProgress; + graph: DirectiveGraphResponse | null; + loading: boolean; + onBack: () => void; + onRefresh: () => void; + onStart: () => void; + onPause: () => void; + onResume: () => void; + onStop: () => void; +} + +function DirectiveDetail({ + directive, + graph, + loading, + onBack, + onRefresh, + onStart, + onPause, + onResume, + onStop, +}: DirectiveDetailProps) { + const [activeTab, setActiveTab] = useState<"overview" | "chain" | "events" | "evaluations" | "approvals" | "verifiers">("overview"); + + if (loading) { + return ( + <div className="panel h-full flex items-center justify-center"> + <p className="font-mono text-xs text-[#556677]">Loading...</p> + </div> + ); + } + + const statusColor = { + draft: "text-[#556677] bg-[#556677]/10 border-[#556677]/30", + planning: "text-yellow-400 bg-yellow-400/10 border-yellow-400/30", + active: "text-green-400 bg-green-400/10 border-green-400/30", + paused: "text-yellow-400 bg-yellow-400/10 border-yellow-400/30", + completed: "text-[#75aafc] bg-[#75aafc]/10 border-[#75aafc]/30", + archived: "text-[#556677] bg-[#556677]/10 border-[#556677]/30", + failed: "text-red-400 bg-red-400/10 border-red-400/30", + }[directive.status] || "text-[#556677] bg-[#556677]/10 border-[#556677]/30"; + + return ( + <div className="panel h-full flex flex-col overflow-hidden"> + {/* Header */} + <div className="p-3 border-b border-[rgba(117,170,252,0.15)]"> + <div className="flex items-center justify-between"> + <div className="flex items-center gap-3"> + <button + onClick={onBack} + className="font-mono text-xs text-[#556677] hover:text-[#9bc3ff]" + > + ← Back + </button> + <h2 className="font-mono text-sm text-[#dbe7ff]"> + {directive.title || directive.goal.slice(0, 50)} + </h2> + <span className={`px-2 py-0.5 font-mono text-[10px] uppercase border ${statusColor}`}> + {directive.status} + </span> + </div> + <div className="flex items-center gap-2"> + {directive.status === "draft" && ( + <button + onClick={onStart} + className="px-3 py-1 font-mono text-[10px] text-[#dbe7ff] bg-green-700 border border-green-600 hover:bg-green-600 uppercase" + > + Start + </button> + )} + {directive.status === "active" && ( + <button + onClick={onPause} + className="px-3 py-1 font-mono text-[10px] text-[#dbe7ff] bg-yellow-700 border border-yellow-600 hover:bg-yellow-600 uppercase" + > + Pause + </button> + )} + {directive.status === "paused" && ( + <button + onClick={onResume} + className="px-3 py-1 font-mono text-[10px] text-[#dbe7ff] bg-green-700 border border-green-600 hover:bg-green-600 uppercase" + > + Resume + </button> + )} + {["active", "paused"].includes(directive.status) && ( + <button + onClick={onStop} + className="px-3 py-1 font-mono text-[10px] text-[#dbe7ff] bg-red-700 border border-red-600 hover:bg-red-600 uppercase" + > + Stop + </button> + )} + <button + onClick={onRefresh} + className="px-3 py-1 font-mono text-[10px] text-[#9bc3ff] hover:text-[#dbe7ff]" + > + Refresh + </button> + </div> + </div> + </div> + + {/* Tabs */} + <div className="flex gap-1 p-2 border-b border-[rgba(117,170,252,0.1)]"> + {(["overview", "chain", "events", "evaluations", "approvals", "verifiers"] as const).map((tab) => ( + <button + key={tab} + onClick={() => setActiveTab(tab)} + className={`px-3 py-1.5 font-mono text-[10px] uppercase ${ + activeTab === tab + ? "text-[#dbe7ff] bg-[#0f3c78] border border-[#3f6fb3]" + : "text-[#556677] hover:text-[#9bc3ff]" + }`} + > + {tab} + {tab === "approvals" && directive.pendingApprovals.length > 0 && ( + <span className="ml-1 px-1 bg-yellow-500 text-black rounded text-[8px]"> + {directive.pendingApprovals.length} + </span> + )} + </button> + ))} + </div> + + {/* Tab Content */} + <div className="flex-1 overflow-y-auto p-4"> + {activeTab === "overview" && ( + <OverviewTab directive={directive} /> + )} + {activeTab === "chain" && ( + <ChainTab directive={directive} graph={graph} /> + )} + {activeTab === "events" && ( + <EventsTab directive={directive} /> + )} + {activeTab === "evaluations" && ( + <EvaluationsTab directive={directive} /> + )} + {activeTab === "approvals" && ( + <ApprovalsTab directive={directive} onRefresh={onRefresh} /> + )} + {activeTab === "verifiers" && ( + <VerifiersTab directive={directive} /> + )} + </div> + </div> + ); +} + +// ============================================================================= +// Tab Components +// ============================================================================= + +function OverviewTab({ directive }: { directive: DirectiveWithProgress }) { + return ( + <div className="space-y-6"> + {/* Goal */} + <div> + <h3 className="font-mono text-xs text-[#75aafc] uppercase mb-2">Goal</h3> + <p className="font-mono text-sm text-[#dbe7ff] whitespace-pre-wrap"> + {directive.goal} + </p> + </div> + + {/* Progress */} + <div> + <h3 className="font-mono text-xs text-[#75aafc] uppercase mb-2">Progress</h3> + <div className="grid grid-cols-3 gap-4"> + <div className="p-3 bg-[rgba(117,170,252,0.05)] border border-[rgba(117,170,252,0.15)]"> + <div className="font-mono text-2xl text-[#dbe7ff]"> + {directive.chain?.completedSteps || 0} + </div> + <div className="font-mono text-[10px] text-[#556677] uppercase">Completed Steps</div> + </div> + <div className="p-3 bg-[rgba(117,170,252,0.05)] border border-[rgba(117,170,252,0.15)]"> + <div className="font-mono text-2xl text-[#dbe7ff]"> + {directive.chain?.totalSteps || 0} + </div> + <div className="font-mono text-[10px] text-[#556677] uppercase">Total Steps</div> + </div> + <div className="p-3 bg-[rgba(117,170,252,0.05)] border border-[rgba(117,170,252,0.15)]"> + <div className="font-mono text-2xl text-[#dbe7ff]"> + {directive.chain?.currentConfidence != null + ? `${Math.round((directive.chain?.currentConfidence ?? 0) * 100)}%` + : "-"} + </div> + <div className="font-mono text-[10px] text-[#556677] uppercase">Confidence</div> + </div> + </div> + </div> + + {/* Configuration */} + <div> + <h3 className="font-mono text-xs text-[#75aafc] uppercase mb-2">Configuration</h3> + <div className="grid grid-cols-2 gap-2 text-sm"> + <div className="flex justify-between"> + <span className="font-mono text-[#556677]">Autonomy Level</span> + <span className="font-mono text-[#dbe7ff]">{directive.autonomyLevel}</span> + </div> + <div className="flex justify-between"> + <span className="font-mono text-[#556677]">Max Rework Cycles</span> + <span className="font-mono text-[#dbe7ff]">{directive.maxReworkCycles}</span> + </div> + <div className="flex justify-between"> + <span className="font-mono text-[#556677]">Green Threshold</span> + <span className="font-mono text-[#dbe7ff]">{directive.confidenceThresholdGreen}</span> + </div> + <div className="flex justify-between"> + <span className="font-mono text-[#556677]">Yellow Threshold</span> + <span className="font-mono text-[#dbe7ff]">{directive.confidenceThresholdYellow}</span> + </div> + </div> + </div> + + {/* Repository */} + {directive.repositoryUrl && ( + <div> + <h3 className="font-mono text-xs text-[#75aafc] uppercase mb-2">Repository</h3> + <p className="font-mono text-sm text-[#9bc3ff]">{directive.repositoryUrl}</p> + </div> + )} + </div> + ); +} + +// Step status colors for both list and DAG views +const stepStatusStyles: Record<StepStatus, { border: string; bg: string; text: string }> = { + pending: { border: "#556677", bg: "#556677", text: "#556677" }, + ready: { border: "#3b82f6", bg: "#3b82f6", text: "#3b82f6" }, + running: { border: "#22c55e", bg: "#22c55e", text: "#22c55e" }, + evaluating: { border: "#eab308", bg: "#eab308", text: "#eab308" }, + passed: { border: "#75aafc", bg: "#75aafc", text: "#75aafc" }, + failed: { border: "#ef4444", bg: "#ef4444", text: "#ef4444" }, + rework: { border: "#f97316", bg: "#f97316", text: "#f97316" }, + skipped: { border: "#556677", bg: "#556677", text: "#556677" }, + blocked: { border: "#ef4444", bg: "#ef4444", text: "#ef4444" }, +}; + +// Confidence level colors +const confidenceColors: Record<ConfidenceLevel, string> = { + green: "#22c55e", + yellow: "#eab308", + red: "#ef4444", +}; + +// Node dimensions +const NODE_WIDTH = 180; +const NODE_HEIGHT = 70; + +// Custom node component for steps +function StepNodeComponent({ data }: { data: DirectiveGraphNode & { selected?: boolean } }) { + const styles = stepStatusStyles[data.status] || stepStatusStyles.pending; + const isRunning = data.status === "running" || data.status === "evaluating"; + + return ( + <div + className={`rounded-lg border-2 bg-[#0a1628] overflow-hidden ${ + isRunning ? "animate-pulse" : "" + }`} + style={{ + width: NODE_WIDTH, + height: NODE_HEIGHT, + borderColor: styles.border, + borderStyle: data.status === "pending" ? "dashed" : "solid", + }} + > + <Handle + type="target" + position={Position.Top} + className="!bg-[#75aafc] !w-3 !h-3 !border-2 !border-[#0a1628]" + /> + + {/* Status indicator bar */} + <div className="h-1.5" style={{ backgroundColor: styles.bg }} /> + + {/* Content */} + <div className="p-2"> + <div className="flex items-center justify-between mb-1"> + <span className="font-mono text-xs text-[#dbe7ff] truncate flex-1">{data.name}</span> + {data.confidenceScore !== null && data.confidenceLevel && ( + <div + className="w-2 h-2 rounded-full flex-shrink-0 ml-1" + style={{ backgroundColor: confidenceColors[data.confidenceLevel] }} + title={`Confidence: ${Math.round(data.confidenceScore * 100)}%`} + /> + )} + </div> + <div className="flex items-center justify-between"> + <span + className="font-mono text-[10px] uppercase px-1.5 py-0.5 rounded" + style={{ + color: styles.text, + backgroundColor: `${styles.bg}20`, + }} + > + {data.status} + </span> + <span className="font-mono text-[10px] text-[#8b949e]">{data.stepType}</span> + </div> + </div> + + <Handle + type="source" + position={Position.Bottom} + className="!bg-[#f59e0b] !w-3 !h-3 !border-2 !border-[#0a1628]" + /> + </div> + ); +} + +// Node types for React Flow +const nodeTypes = { + step: StepNodeComponent, +}; + +function ChainTab({ directive, graph }: { directive: DirectiveWithProgress; graph: DirectiveGraphResponse | null }) { + const [viewMode, setViewMode] = useState<"dag" | "list">("dag"); + + // Convert graph to React Flow nodes and edges + const { nodes, edges } = useMemo(() => { + if (!graph || !graph.nodes.length) { + // Fallback: generate positions from directive.steps + const stepNodes = directive.steps.map((step, index) => ({ + id: step.id, + type: "step" as const, + position: { + x: (index % 3) * 220 + 50, + y: Math.floor(index / 3) * 120 + 50, + }, + data: { + id: step.id, + name: step.name, + stepType: step.stepType, + status: step.status, + confidenceScore: step.confidenceScore, + confidenceLevel: step.confidenceLevel, + contractId: step.contractId, + editorX: null, + editorY: null, + }, + })); + + // Build edges from dependencies + const stepEdges: Edge[] = []; + directive.steps.forEach((step) => { + step.dependsOn.forEach((depName) => { + const depStep = directive.steps.find((s) => s.name === depName); + if (depStep) { + stepEdges.push({ + id: `${depStep.id}-${step.id}`, + source: depStep.id, + target: step.id, + type: "smoothstep", + markerEnd: { type: MarkerType.ArrowClosed, color: "#556677" }, + style: { stroke: "#556677", strokeWidth: 2 }, + }); + } + }); + }); + + return { nodes: stepNodes, edges: stepEdges }; + } + + // Use graph data + const graphNodes = graph.nodes.map((node) => ({ + id: node.id, + type: "step" as const, + position: { + x: node.editorX ?? 50, + y: node.editorY ?? 50, + }, + data: { ...node }, + })); + + const graphEdges: Edge[] = graph.edges.map((edge) => ({ + id: `${edge.source}-${edge.target}`, + source: edge.source, + target: edge.target, + type: "smoothstep", + markerEnd: { type: MarkerType.ArrowClosed, color: "#556677" }, + style: { stroke: "#556677", strokeWidth: 2 }, + })); + + return { nodes: graphNodes, edges: graphEdges }; + }, [graph, directive.steps]); + + if (!directive.chain) { + return ( + <div className="text-center py-8"> + <p className="font-mono text-sm text-[#556677]"> + No chain generated yet. Start the directive to generate a chain. + </p> + </div> + ); + } + + return ( + <div className="space-y-4"> + {/* Chain info header */} + <div className="flex items-center justify-between p-3 bg-[rgba(117,170,252,0.05)] border border-[rgba(117,170,252,0.15)]"> + <div> + <div className="font-mono text-sm text-[#dbe7ff]">{directive.chain.name}</div> + <div className="font-mono text-[10px] text-[#556677]">Generation {directive.chain.generation}</div> + </div> + <div className="flex items-center gap-4"> + <div className="font-mono text-xs text-[#556677]"> + {directive.chain.completedSteps}/{directive.chain.totalSteps} steps + </div> + {/* View toggle */} + <div className="flex border border-[rgba(117,170,252,0.2)]"> + <button + onClick={() => setViewMode("dag")} + className={`px-2 py-1 font-mono text-[10px] uppercase ${ + viewMode === "dag" + ? "bg-[rgba(117,170,252,0.2)] text-[#75aafc]" + : "text-[#556677] hover:text-[#75aafc]" + }`} + > + DAG + </button> + <button + onClick={() => setViewMode("list")} + className={`px-2 py-1 font-mono text-[10px] uppercase ${ + viewMode === "list" + ? "bg-[rgba(117,170,252,0.2)] text-[#75aafc]" + : "text-[#556677] hover:text-[#75aafc]" + }`} + > + List + </button> + </div> + </div> + </div> + + {viewMode === "dag" ? ( + /* DAG visualization */ + <div className="h-[400px] border border-[rgba(117,170,252,0.1)] rounded bg-[#050d18]"> + {directive.steps.length === 0 ? ( + <div className="flex items-center justify-center h-full"> + <p className="font-mono text-sm text-[#556677]">No steps in chain</p> + </div> + ) : ( + <ReactFlow + nodes={nodes} + edges={edges} + nodeTypes={nodeTypes} + fitView + fitViewOptions={{ padding: 0.2 }} + minZoom={0.5} + maxZoom={1.5} + defaultEdgeOptions={{ + type: "smoothstep", + style: { stroke: "#556677", strokeWidth: 2 }, + }} + > + <Background variant={BackgroundVariant.Dots} gap={20} size={1} color="#1a2a3a" /> + <Controls className="!bg-[#0a1628] !border-[rgba(117,170,252,0.2)]" /> + </ReactFlow> + )} + </div> + ) : ( + /* List view */ + <div className="space-y-2"> + <h3 className="font-mono text-xs text-[#75aafc] uppercase">Steps</h3> + {directive.steps.length === 0 ? ( + <p className="font-mono text-sm text-[#556677]">No steps in chain</p> + ) : ( + directive.steps.map((step) => { + const styles = stepStatusStyles[step.status] || stepStatusStyles.pending; + + return ( + <div + key={step.id} + className="p-3 bg-[rgba(117,170,252,0.02)] border border-[rgba(117,170,252,0.1)]" + > + <div className="flex items-center justify-between"> + <div className="flex items-center gap-2"> + <span className="font-mono text-sm text-[#dbe7ff]">{step.name}</span> + <span + className="px-1.5 py-0.5 font-mono text-[10px] uppercase border" + style={{ color: styles.text, borderColor: `${styles.border}50` }} + > + {step.status} + </span> + {step.confidenceScore !== null && ( + <span className="font-mono text-[10px] text-[#556677]"> + ({Math.round(step.confidenceScore * 100)}%) + </span> + )} + </div> + <div className="font-mono text-[10px] text-[#556677]">{step.stepType}</div> + </div> + {step.description && ( + <p className="font-mono text-xs text-[#556677] mt-1">{step.description}</p> + )} + {step.dependsOn.length > 0 && ( + <div className="font-mono text-[10px] text-[#556677] mt-1"> + Depends on: {step.dependsOn.join(", ")} + </div> + )} + </div> + ); + }) + )} + </div> + )} + </div> + ); +} + +function EventsTab({ directive }: { directive: DirectiveWithProgress }) { + // Subscribe to real-time events via SSE + const { events: streamEvents, isConnected, error: sseError } = useDirectiveEventSubscription(directive.id); + + // Combine initial events with streamed events (avoiding duplicates) + const allEvents = useMemo(() => { + const eventMap = new Map(); + // Add initial events first + directive.recentEvents.forEach((e) => eventMap.set(e.id, e)); + // Add streamed events (will override any duplicates) + streamEvents.forEach((e) => eventMap.set(e.id, e)); + // Sort by created_at descending (most recent first) + return Array.from(eventMap.values()).sort( + (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime() + ); + }, [directive.recentEvents, streamEvents]); + + return ( + <div className="space-y-4"> + {/* Connection status */} + <div className="flex items-center justify-between text-[10px] font-mono"> + <div className="flex items-center gap-2"> + <span className={isConnected ? "text-green-400" : "text-[#556677]"}> + {isConnected ? "● Live" : "○ Connecting..."} + </span> + {sseError && <span className="text-red-400">{sseError}</span>} + </div> + <span className="text-[#556677]">{allEvents.length} events</span> + </div> + + {/* Event list */} + {allEvents.length === 0 ? ( + <div className="text-center py-8"> + <p className="font-mono text-sm text-[#556677]">No events yet</p> + </div> + ) : ( + <div className="space-y-2"> + {allEvents.map((event) => { + const severityColors: Record<string, string> = { + info: "text-[#75aafc]", + warning: "text-yellow-400", + error: "text-red-400", + critical: "text-red-600", + }; + const severityColor = severityColors[event.severity] || "text-[#556677]"; + + return ( + <div + key={event.id} + className="p-3 bg-[rgba(117,170,252,0.02)] border border-[rgba(117,170,252,0.1)]" + > + <div className="flex items-center justify-between"> + <div className="flex items-center gap-2"> + <span className={`font-mono text-xs ${severityColor}`}>{event.eventType}</span> + <span className="font-mono text-[10px] text-[#556677]">{event.actorType}</span> + </div> + <span className="font-mono text-[10px] text-[#556677]"> + {new Date(event.createdAt).toLocaleString()} + </span> + </div> + {event.eventData != null && ( + <pre className="font-mono text-[10px] text-[#556677] mt-1 overflow-x-auto"> + {JSON.stringify(event.eventData, null, 2)} + </pre> + )} + </div> + ); + })} + </div> + )} + </div> + ); +} + +function EvaluationsTab({ directive: _directive }: { directive: DirectiveWithProgress }) { + // TODO: Fetch evaluations separately + return ( + <div className="text-center py-8"> + <p className="font-mono text-sm text-[#556677]"> + Evaluations will be shown here after steps are evaluated + </p> + </div> + ); +} + +function ApprovalsTab({ directive, onRefresh }: { directive: DirectiveWithProgress; onRefresh: () => void }) { + if (directive.pendingApprovals.length === 0) { + return ( + <div className="text-center py-8"> + <p className="font-mono text-sm text-[#556677]">No pending approvals</p> + </div> + ); + } + + const handleApprove = async (approvalId: string) => { + try { + const { approveDirectiveRequest } = await import("../lib/api"); + await approveDirectiveRequest(directive.id, approvalId); + onRefresh(); + } catch (err) { + console.error("Failed to approve:", err); + } + }; + + const handleDeny = async (approvalId: string) => { + try { + const { denyDirectiveRequest } = await import("../lib/api"); + await denyDirectiveRequest(directive.id, approvalId); + onRefresh(); + } catch (err) { + console.error("Failed to deny:", err); + } + }; + + return ( + <div className="space-y-3"> + {directive.pendingApprovals.map((approval) => { + const urgencyColor = { + low: "text-[#556677]", + normal: "text-[#75aafc]", + high: "text-yellow-400", + critical: "text-red-400", + }[approval.urgency] || "text-[#556677]"; + + return ( + <div + key={approval.id} + className="p-4 bg-[rgba(117,170,252,0.05)] border border-[rgba(117,170,252,0.2)]" + > + <div className="flex items-start justify-between"> + <div> + <div className="flex items-center gap-2"> + <span className="font-mono text-sm text-[#dbe7ff]">{approval.approvalType}</span> + <span className={`font-mono text-[10px] uppercase ${urgencyColor}`}> + {approval.urgency} + </span> + </div> + <p className="font-mono text-xs text-[#9bc3ff] mt-1">{approval.description}</p> + </div> + <div className="flex gap-2"> + <button + onClick={() => handleApprove(approval.id)} + className="px-3 py-1 font-mono text-[10px] text-[#dbe7ff] bg-green-700 border border-green-600 hover:bg-green-600 uppercase" + > + Approve + </button> + <button + onClick={() => handleDeny(approval.id)} + className="px-3 py-1 font-mono text-[10px] text-[#dbe7ff] bg-red-700 border border-red-600 hover:bg-red-600 uppercase" + > + Deny + </button> + </div> + </div> + </div> + ); + })} + </div> + ); +} + +function VerifiersTab({ directive: _directive }: { directive: DirectiveWithProgress }) { + // TODO: Fetch verifiers separately + return ( + <div className="text-center py-8"> + <p className="font-mono text-sm text-[#556677]"> + Verifiers will be shown here. Use auto-detect to find available verifiers. + </p> + </div> + ); +} + +// ============================================================================= +// Create Directive Modal +// ============================================================================= + +interface CreateDirectiveModalProps { + onSubmit: (goal: string, repositoryUrl: string | undefined, autonomyLevel: AutonomyLevel) => void; + onCancel: () => void; +} + +function CreateDirectiveModal({ onSubmit, onCancel }: CreateDirectiveModalProps) { + const [goal, setGoal] = useState(""); + const [repositoryUrl, setRepositoryUrl] = useState(""); + const [autonomyLevel, setAutonomyLevel] = useState<AutonomyLevel>("guardrails"); + const [suggestions, setSuggestions] = useState<RepositoryHistoryEntry[]>([]); + const [showSuggestions, setShowSuggestions] = useState(false); + + // Load suggestions + useEffect(() => { + getRepositorySuggestions("remote", undefined, 5) + .then((res) => { + setSuggestions(res.entries); + }) + .catch(() => { + setSuggestions([]); + }); + }, []); + + const handleSubmit = () => { + if (goal.trim()) { + onSubmit(goal.trim(), repositoryUrl.trim() || undefined, autonomyLevel); + } + }; + + return ( + <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50 p-4"> + <div className="w-full max-w-lg p-6 bg-[#0a1628] border border-[rgba(117,170,252,0.3)] max-h-[90vh] overflow-y-auto"> + <h3 className="font-mono text-sm text-[#75aafc] uppercase mb-4"> + Create Directive + </h3> + + <div className="space-y-4"> + {/* Goal */} + <div> + <label className="block font-mono text-xs text-[#8b949e] uppercase mb-1"> + Goal * + </label> + <textarea + value={goal} + onChange={(e) => setGoal(e.target.value)} + placeholder="Describe what you want to accomplish..." + rows={3} + className="w-full px-3 py-2 bg-[#0d1b2d] border border-[#3f6fb3] text-[#dbe7ff] font-mono text-sm focus:outline-none focus:border-[#75aafc] resize-none" + autoFocus + /> + </div> + + {/* Repository URL */} + <div> + <label className="block font-mono text-xs text-[#8b949e] uppercase mb-1"> + Repository URL (optional) + </label> + <div className="relative"> + <input + type="text" + value={repositoryUrl} + onChange={(e) => setRepositoryUrl(e.target.value)} + onFocus={() => suggestions.length > 0 && setShowSuggestions(true)} + onBlur={() => setTimeout(() => setShowSuggestions(false), 200)} + placeholder="https://github.com/owner/repo" + className="w-full px-3 py-2 bg-[#0d1b2d] border border-[#3f6fb3] text-[#dbe7ff] font-mono text-sm focus:outline-none focus:border-[#75aafc]" + /> + {showSuggestions && suggestions.length > 0 && ( + <div className="absolute top-full left-0 right-0 mt-1 border border-[rgba(117,170,252,0.2)] bg-[#0a1525] max-h-32 overflow-y-auto z-10"> + {suggestions.map((s) => ( + <button + key={s.id} + type="button" + onClick={() => { + setRepositoryUrl(s.repositoryUrl || ""); + setShowSuggestions(false); + }} + className="w-full text-left px-3 py-2 font-mono text-xs hover:bg-[rgba(117,170,252,0.1)] border-b border-[rgba(117,170,252,0.1)] last:border-b-0" + > + <div className="text-[#9bc3ff] truncate">{s.name}</div> + <div className="text-[10px] text-[#556677] truncate">{s.repositoryUrl}</div> + </button> + ))} + </div> + )} + </div> + </div> + + {/* Autonomy Level */} + <div> + <label className="block font-mono text-xs text-[#8b949e] uppercase mb-2"> + Autonomy Level + </label> + <div className="flex gap-2"> + {(["full_auto", "guardrails", "manual"] as const).map((level) => ( + <button + key={level} + type="button" + onClick={() => setAutonomyLevel(level)} + className={`flex-1 px-3 py-2 font-mono text-xs uppercase ${ + autonomyLevel === level + ? "text-[#dbe7ff] bg-[#0f3c78] border border-[#3f6fb3]" + : "text-[#556677] border border-[rgba(117,170,252,0.2)] hover:border-[#3f6fb3]" + }`} + > + {level.replace("_", " ")} + </button> + ))} + </div> + <p className="font-mono text-[10px] text-[#556677] mt-1"> + {autonomyLevel === "full_auto" && "Automatic progression without approval gates"} + {autonomyLevel === "guardrails" && "Request approval for yellow/red confidence scores"} + {autonomyLevel === "manual" && "Request approval for all step completions"} + </p> + </div> + + <p className="font-mono text-xs text-[#8b949e]"> + A directive is a top-level goal that generates a chain of steps. Each step spawns + contracts that are verified before progression. + </p> + + {/* Actions */} + <div className="flex gap-2 justify-end pt-2"> + <button + onClick={onCancel} + className="px-4 py-2 font-mono text-xs text-[#9bc3ff] hover:text-[#dbe7ff] transition-colors" + > + Cancel + </button> + <button + onClick={handleSubmit} + disabled={!goal.trim()} + className="px-4 py-2 font-mono text-xs text-[#dbe7ff] bg-[#0f3c78] border border-[#3f6fb3] hover:bg-[#153667] transition-colors disabled:opacity-50 disabled:cursor-not-allowed" + > + Create + </button> + </div> + </div> + </div> + </div> + ); +} diff --git a/makima/frontend/tsconfig.tsbuildinfo b/makima/frontend/tsconfig.tsbuildinfo index 425babe..966ee38 100644 --- a/makima/frontend/tsconfig.tsbuildinfo +++ b/makima/frontend/tsconfig.tsbuildinfo @@ -1 +1 @@ -{"root":["./src/main.tsx","./src/vite-env.d.ts","./src/components/gridoverlay.tsx","./src/components/japanesehovertext.tsx","./src/components/logo.tsx","./src/components/masthead.tsx","./src/components/navstrip.tsx","./src/components/phaseconfirmationnotification.tsx","./src/components/protectedroute.tsx","./src/components/rewritelink.tsx","./src/components/simplemarkdown.tsx","./src/components/supervisorquestionnotification.tsx","./src/components/chains/chaineditor.tsx","./src/components/chains/chainlist.tsx","./src/components/charts/chartrenderer.tsx","./src/components/contracts/commandmodepanel.tsx","./src/components/contracts/contractcliinput.tsx","./src/components/contracts/contractcontextmenu.tsx","./src/components/contracts/contractdetail.tsx","./src/components/contracts/contractlist.tsx","./src/components/contracts/phasebadge.tsx","./src/components/contracts/phaseconfirmationmodal.tsx","./src/components/contracts/phasedeliverablespanel.tsx","./src/components/contracts/phasehint.tsx","./src/components/contracts/phaseprogressbar.tsx","./src/components/contracts/quickactionbuttons.tsx","./src/components/contracts/repositorypanel.tsx","./src/components/contracts/taskderivationpreview.tsx","./src/components/files/bodyrenderer.tsx","./src/components/files/cliinput.tsx","./src/components/files/conflictnotification.tsx","./src/components/files/elementcontextmenu.tsx","./src/components/files/filedetail.tsx","./src/components/files/filelist.tsx","./src/components/files/reposyncindicator.tsx","./src/components/files/updatenotification.tsx","./src/components/files/versionhistorydropdown.tsx","./src/components/history/checkpointcard.tsx","./src/components/history/checkpointlist.tsx","./src/components/history/conversationmessage.tsx","./src/components/history/conversationview.tsx","./src/components/history/historyfilters.tsx","./src/components/history/resumecontrols.tsx","./src/components/history/timelineeventcard.tsx","./src/components/history/timelinelist.tsx","./src/components/history/index.ts","./src/components/listen/contractpickermodal.tsx","./src/components/listen/controlpanel.tsx","./src/components/listen/discusscontractmodal.tsx","./src/components/listen/speakerpanel.tsx","./src/components/listen/transcriptanalysispanel.tsx","./src/components/listen/transcriptpanel.tsx","./src/components/mesh/branchtaskmodal.tsx","./src/components/mesh/contractcompletequestion.tsx","./src/components/mesh/directoryinput.tsx","./src/components/mesh/gitactionspanel.tsx","./src/components/mesh/inlinesubtaskeditor.tsx","./src/components/mesh/mergeconflictresolver.tsx","./src/components/mesh/overlaydiffviewer.tsx","./src/components/mesh/prpreview.tsx","./src/components/mesh/patcheslistpanel.tsx","./src/components/mesh/subtasktree.tsx","./src/components/mesh/taskdetail.tsx","./src/components/mesh/tasklist.tsx","./src/components/mesh/taskoutput.tsx","./src/components/mesh/tasktree.tsx","./src/components/mesh/unifiedmeshchatinput.tsx","./src/components/mesh/worktreefilespanel.tsx","./src/components/workflow/phasecolumn.tsx","./src/components/workflow/workflowboard.tsx","./src/components/workflow/workflowcontractcard.tsx","./src/contexts/authcontext.tsx","./src/contexts/supervisorquestionscontext.tsx","./src/hooks/usechains.ts","./src/hooks/usecontracts.ts","./src/hooks/usefilesubscription.ts","./src/hooks/usefiles.ts","./src/hooks/usemeshchathistory.ts","./src/hooks/usemicrophone.ts","./src/hooks/usespeakwebsocket.ts","./src/hooks/usetasksubscription.ts","./src/hooks/usetasks.ts","./src/hooks/usetextscramble.ts","./src/hooks/useversionhistory.ts","./src/hooks/usewebsocket.ts","./src/lib/api.ts","./src/lib/listenapi.ts","./src/lib/markdown.ts","./src/lib/supabase.ts","./src/routes/_index.tsx","./src/routes/chains.tsx","./src/routes/contract-file.tsx","./src/routes/contracts.tsx","./src/routes/files.tsx","./src/routes/history.tsx","./src/routes/listen.tsx","./src/routes/login.tsx","./src/routes/mesh.tsx","./src/routes/settings.tsx","./src/routes/speak.tsx","./src/routes/workflow.tsx","./src/types/messages.ts"],"version":"5.9.3"}
\ No newline at end of file +{"root":["./src/main.tsx","./src/vite-env.d.ts","./src/components/gridoverlay.tsx","./src/components/japanesehovertext.tsx","./src/components/logo.tsx","./src/components/masthead.tsx","./src/components/navstrip.tsx","./src/components/phaseconfirmationnotification.tsx","./src/components/protectedroute.tsx","./src/components/rewritelink.tsx","./src/components/simplemarkdown.tsx","./src/components/supervisorquestionnotification.tsx","./src/components/chains/chaineditor.tsx","./src/components/chains/chainlist.tsx","./src/components/charts/chartrenderer.tsx","./src/components/contracts/commandmodepanel.tsx","./src/components/contracts/contractcliinput.tsx","./src/components/contracts/contractcontextmenu.tsx","./src/components/contracts/contractdetail.tsx","./src/components/contracts/contractlist.tsx","./src/components/contracts/phasebadge.tsx","./src/components/contracts/phaseconfirmationmodal.tsx","./src/components/contracts/phasedeliverablespanel.tsx","./src/components/contracts/phasehint.tsx","./src/components/contracts/phaseprogressbar.tsx","./src/components/contracts/quickactionbuttons.tsx","./src/components/contracts/repositorypanel.tsx","./src/components/contracts/taskderivationpreview.tsx","./src/components/files/bodyrenderer.tsx","./src/components/files/cliinput.tsx","./src/components/files/conflictnotification.tsx","./src/components/files/elementcontextmenu.tsx","./src/components/files/filedetail.tsx","./src/components/files/filelist.tsx","./src/components/files/reposyncindicator.tsx","./src/components/files/updatenotification.tsx","./src/components/files/versionhistorydropdown.tsx","./src/components/history/checkpointcard.tsx","./src/components/history/checkpointlist.tsx","./src/components/history/conversationmessage.tsx","./src/components/history/conversationview.tsx","./src/components/history/historyfilters.tsx","./src/components/history/resumecontrols.tsx","./src/components/history/timelineeventcard.tsx","./src/components/history/timelinelist.tsx","./src/components/history/index.ts","./src/components/listen/contractpickermodal.tsx","./src/components/listen/controlpanel.tsx","./src/components/listen/discusscontractmodal.tsx","./src/components/listen/speakerpanel.tsx","./src/components/listen/transcriptanalysispanel.tsx","./src/components/listen/transcriptpanel.tsx","./src/components/mesh/branchtaskmodal.tsx","./src/components/mesh/contractcompletequestion.tsx","./src/components/mesh/directoryinput.tsx","./src/components/mesh/gitactionspanel.tsx","./src/components/mesh/inlinesubtaskeditor.tsx","./src/components/mesh/mergeconflictresolver.tsx","./src/components/mesh/overlaydiffviewer.tsx","./src/components/mesh/prpreview.tsx","./src/components/mesh/patcheslistpanel.tsx","./src/components/mesh/subtasktree.tsx","./src/components/mesh/taskdetail.tsx","./src/components/mesh/tasklist.tsx","./src/components/mesh/taskoutput.tsx","./src/components/mesh/tasktree.tsx","./src/components/mesh/unifiedmeshchatinput.tsx","./src/components/mesh/worktreefilespanel.tsx","./src/components/workflow/phasecolumn.tsx","./src/components/workflow/workflowboard.tsx","./src/components/workflow/workflowcontractcard.tsx","./src/contexts/authcontext.tsx","./src/contexts/supervisorquestionscontext.tsx","./src/hooks/usechains.ts","./src/hooks/usecontracts.ts","./src/hooks/usedirectives.ts","./src/hooks/usefilesubscription.ts","./src/hooks/usefiles.ts","./src/hooks/usemeshchathistory.ts","./src/hooks/usemicrophone.ts","./src/hooks/usespeakwebsocket.ts","./src/hooks/usetasksubscription.ts","./src/hooks/usetasks.ts","./src/hooks/usetextscramble.ts","./src/hooks/useversionhistory.ts","./src/hooks/usewebsocket.ts","./src/lib/api.ts","./src/lib/listenapi.ts","./src/lib/markdown.ts","./src/lib/supabase.ts","./src/routes/_index.tsx","./src/routes/chains.tsx","./src/routes/contract-file.tsx","./src/routes/contracts.tsx","./src/routes/directives.tsx","./src/routes/files.tsx","./src/routes/history.tsx","./src/routes/listen.tsx","./src/routes/login.tsx","./src/routes/mesh.tsx","./src/routes/settings.tsx","./src/routes/speak.tsx","./src/routes/workflow.tsx","./src/types/messages.ts"],"version":"5.9.3"}
\ No newline at end of file diff --git a/makima/migrations/20260206000000_create_directive_system.sql b/makima/migrations/20260206000000_create_directive_system.sql new file mode 100644 index 0000000..ed780ef --- /dev/null +++ b/makima/migrations/20260206000000_create_directive_system.sql @@ -0,0 +1,320 @@ +-- ============================================================================ +-- Migration: create_directive_system.sql +-- Replaces: chains, chain_contracts, chain_contract_definitions, +-- chain_directives, contract_evaluations, chain_events, +-- chain_repositories +-- ============================================================================ + +-- Drop old chain system tables (cascade to remove FKs) +DROP TABLE IF EXISTS contract_evaluations CASCADE; +DROP TABLE IF EXISTS chain_events CASCADE; +DROP TABLE IF EXISTS chain_contract_definitions CASCADE; +DROP TABLE IF EXISTS chain_contracts CASCADE; +DROP TABLE IF EXISTS chain_directives CASCADE; +DROP TABLE IF EXISTS chain_repositories CASCADE; +DROP TABLE IF EXISTS chains CASCADE; + +-- Remove old chain-related columns from contracts +ALTER TABLE contracts DROP COLUMN IF EXISTS chain_id; +ALTER TABLE contracts DROP COLUMN IF EXISTS spawned_chain_id; +ALTER TABLE contracts DROP COLUMN IF EXISTS is_chain_directive; + +-- ============================================================================ +-- 1. DIRECTIVES -- the top-level entity +-- ============================================================================ +CREATE TABLE directives ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + owner_id UUID NOT NULL REFERENCES owners(id) ON DELETE CASCADE, + + -- Goal specification + title VARCHAR(500) NOT NULL, + goal TEXT NOT NULL, + + -- Structured specification (JSONB arrays) + requirements JSONB NOT NULL DEFAULT '[]', + acceptance_criteria JSONB NOT NULL DEFAULT '[]', + constraints JSONB NOT NULL DEFAULT '[]', + external_dependencies JSONB NOT NULL DEFAULT '[]', + + -- State + status VARCHAR(32) NOT NULL DEFAULT 'draft', + + -- Autonomy configuration + autonomy_level VARCHAR(32) NOT NULL DEFAULT 'guardrails', + confidence_threshold_green FLOAT NOT NULL DEFAULT 0.85, + confidence_threshold_yellow FLOAT NOT NULL DEFAULT 0.60, + + -- Circuit breaker limits + max_total_cost_usd FLOAT, + max_wall_time_minutes INTEGER, + max_rework_cycles INTEGER DEFAULT 3, + max_chain_regenerations INTEGER DEFAULT 2, + + -- Repository configuration (inherited by all steps) + repository_url VARCHAR(512), + local_path VARCHAR(512), + base_branch VARCHAR(255), + + -- Orchestrator contract reference + orchestrator_contract_id UUID REFERENCES contracts(id) ON DELETE SET NULL, + + -- Tracking + current_chain_id UUID, -- FK added after directive_chains table + chain_generation_count INTEGER NOT NULL DEFAULT 0, + total_cost_usd FLOAT NOT NULL DEFAULT 0.0, + started_at TIMESTAMPTZ, + completed_at TIMESTAMPTZ, + + version INTEGER NOT NULL DEFAULT 1, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_directives_owner_id ON directives(owner_id); +CREATE INDEX idx_directives_status ON directives(status); + +-- Add directive reference to contracts +ALTER TABLE contracts ADD COLUMN directive_id UUID REFERENCES directives(id) ON DELETE SET NULL; +ALTER TABLE contracts ADD COLUMN is_directive_orchestrator BOOLEAN NOT NULL DEFAULT false; +ALTER TABLE contracts ADD COLUMN spawned_directive_id UUID REFERENCES directives(id) ON DELETE SET NULL; + +-- ============================================================================ +-- 2. DIRECTIVE CHAINS -- generated execution plans +-- ============================================================================ +CREATE TABLE directive_chains ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + directive_id UUID NOT NULL REFERENCES directives(id) ON DELETE CASCADE, + generation INTEGER NOT NULL DEFAULT 1, + + -- Plan metadata + name VARCHAR(255) NOT NULL, + description TEXT, + rationale TEXT, + planning_model VARCHAR(100), + + -- State + status VARCHAR(32) NOT NULL DEFAULT 'pending', + + -- Execution tracking + total_steps INTEGER NOT NULL DEFAULT 0, + completed_steps INTEGER NOT NULL DEFAULT 0, + failed_steps INTEGER NOT NULL DEFAULT 0, + current_confidence FLOAT, + + -- Timestamps + started_at TIMESTAMPTZ, + completed_at TIMESTAMPTZ, + version INTEGER NOT NULL DEFAULT 1, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_directive_chains_directive ON directive_chains(directive_id); +CREATE INDEX idx_directive_chains_status ON directive_chains(status); + +-- Add FK from directives to chains +ALTER TABLE directives + ADD CONSTRAINT fk_directives_current_chain + FOREIGN KEY (current_chain_id) REFERENCES directive_chains(id) + ON DELETE SET NULL; + +-- ============================================================================ +-- 3. CHAIN STEPS -- nodes in the DAG +-- ============================================================================ +CREATE TABLE chain_steps ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + chain_id UUID NOT NULL REFERENCES directive_chains(id) ON DELETE CASCADE, + + -- Step definition + name VARCHAR(255) NOT NULL, + description TEXT, + step_type VARCHAR(32) NOT NULL DEFAULT 'execute', + + -- Contract template + contract_type VARCHAR(32) NOT NULL DEFAULT 'simple', + initial_phase VARCHAR(32) DEFAULT 'plan', + task_plan TEXT, + phases TEXT[] DEFAULT '{}', + + -- DAG edges + depends_on UUID[] DEFAULT '{}', + parallel_group VARCHAR(100), + + -- Requirement traceability + requirement_ids TEXT[] DEFAULT '{}', + acceptance_criteria_ids TEXT[] DEFAULT '{}', + + -- Verification configuration + verifier_config JSONB DEFAULT '{}', + + -- State + status VARCHAR(32) NOT NULL DEFAULT 'pending', + + -- Instantiated references + contract_id UUID REFERENCES contracts(id) ON DELETE SET NULL, + supervisor_task_id UUID, + + -- Evaluation tracking + confidence_score FLOAT, + confidence_level VARCHAR(10), + evaluation_count INTEGER NOT NULL DEFAULT 0, + rework_count INTEGER NOT NULL DEFAULT 0, + last_evaluation_id UUID, + + -- Editor layout + editor_x FLOAT DEFAULT 0, + editor_y FLOAT DEFAULT 0, + order_index INTEGER NOT NULL DEFAULT 0, + + -- Timestamps + started_at TIMESTAMPTZ, + completed_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_chain_steps_chain ON chain_steps(chain_id); +CREATE INDEX idx_chain_steps_status ON chain_steps(status); +CREATE INDEX idx_chain_steps_contract ON chain_steps(contract_id) WHERE contract_id IS NOT NULL; + +-- ============================================================================ +-- 4. EVALUATIONS -- programmatic + LLM composite +-- ============================================================================ +CREATE TABLE directive_evaluations ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + directive_id UUID NOT NULL REFERENCES directives(id) ON DELETE CASCADE, + chain_id UUID REFERENCES directive_chains(id) ON DELETE SET NULL, + step_id UUID REFERENCES chain_steps(id) ON DELETE SET NULL, + contract_id UUID REFERENCES contracts(id) ON DELETE SET NULL, + + -- Evaluation metadata + evaluation_type VARCHAR(32) NOT NULL, + evaluation_number INTEGER NOT NULL DEFAULT 1, + evaluator VARCHAR(100), + + -- Results + passed BOOLEAN NOT NULL, + overall_score FLOAT, + confidence_level VARCHAR(10), + + -- Programmatic results + programmatic_results JSONB DEFAULT '[]', + + -- LLM evaluation results + llm_results JSONB DEFAULT '{}', + + -- Composite results + criteria_results JSONB NOT NULL DEFAULT '[]', + summary_feedback TEXT NOT NULL DEFAULT '', + rework_instructions TEXT, + + -- Snapshots + directive_snapshot JSONB, + deliverables_snapshot JSONB, + + -- Timing + started_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + completed_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_evaluations_directive ON directive_evaluations(directive_id); +CREATE INDEX idx_evaluations_step ON directive_evaluations(step_id); +CREATE INDEX idx_evaluations_chain ON directive_evaluations(chain_id); + +-- Add FK from chain_steps to evaluations +ALTER TABLE chain_steps + ADD CONSTRAINT fk_steps_last_evaluation + FOREIGN KEY (last_evaluation_id) REFERENCES directive_evaluations(id) + ON DELETE SET NULL; + +-- ============================================================================ +-- 5. EVENTS -- comprehensive audit stream +-- ============================================================================ +CREATE TABLE directive_events ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + directive_id UUID NOT NULL REFERENCES directives(id) ON DELETE CASCADE, + chain_id UUID REFERENCES directive_chains(id) ON DELETE SET NULL, + step_id UUID REFERENCES chain_steps(id) ON DELETE SET NULL, + + -- Event classification + event_type VARCHAR(64) NOT NULL, + severity VARCHAR(16) NOT NULL DEFAULT 'info', + + -- Payload + event_data JSONB, + + -- Actor + actor_type VARCHAR(32) NOT NULL DEFAULT 'system', + actor_id UUID, + + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_events_directive ON directive_events(directive_id); +CREATE INDEX idx_events_chain ON directive_events(chain_id); +CREATE INDEX idx_events_step ON directive_events(step_id); +CREATE INDEX idx_events_type ON directive_events(event_type); +CREATE INDEX idx_events_created ON directive_events(created_at); + +-- ============================================================================ +-- 6. VERIFIERS -- pluggable verification config +-- ============================================================================ +CREATE TABLE directive_verifiers ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + directive_id UUID NOT NULL REFERENCES directives(id) ON DELETE CASCADE, + + -- Definition + name VARCHAR(100) NOT NULL, + verifier_type VARCHAR(32) NOT NULL, + + -- Configuration + command VARCHAR(1000), + working_directory VARCHAR(500), + timeout_seconds INTEGER DEFAULT 300, + environment JSONB DEFAULT '{}', + + -- Detection + auto_detect BOOLEAN NOT NULL DEFAULT true, + detect_files TEXT[] DEFAULT '{}', + + -- Scoring + weight FLOAT NOT NULL DEFAULT 1.0, + required BOOLEAN NOT NULL DEFAULT false, + + -- State + enabled BOOLEAN NOT NULL DEFAULT true, + last_run_at TIMESTAMPTZ, + last_result JSONB, + + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_verifiers_directive ON directive_verifiers(directive_id); + +-- ============================================================================ +-- 7. APPROVALS -- human-in-the-loop gates +-- ============================================================================ +CREATE TABLE directive_approvals ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + directive_id UUID NOT NULL REFERENCES directives(id) ON DELETE CASCADE, + step_id UUID REFERENCES chain_steps(id) ON DELETE SET NULL, + + -- Request + approval_type VARCHAR(64) NOT NULL, + description TEXT NOT NULL, + context JSONB, + urgency VARCHAR(16) NOT NULL DEFAULT 'normal', + + -- Response + status VARCHAR(32) NOT NULL DEFAULT 'pending', + response TEXT, + responded_by UUID, + responded_at TIMESTAMPTZ, + + expires_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_approvals_directive ON directive_approvals(directive_id); +CREATE INDEX idx_approvals_status ON directive_approvals(status); diff --git a/makima/src/bin/makima.rs b/makima/src/bin/makima.rs index f9c981f..822b21f 100644 --- a/makima/src/bin/makima.rs +++ b/makima/src/bin/makima.rs @@ -7,7 +7,7 @@ use std::sync::Arc; use makima::daemon::api::{ApiClient, CreateContractRequest}; use makima::daemon::cli::{ Cli, CliConfig, Commands, ConfigCommand, ContractCommand, ChainCommand, - SupervisorCommand, ViewArgs, + DirectiveCommand, SupervisorCommand, ViewArgs, }; use makima::daemon::tui::{self, Action, App, ListItem, ViewType, TuiWsClient, WsEvent, OutputLine, OutputMessageType, WsConnectionState, RepositorySuggestion}; use makima::daemon::config::{DaemonConfig, RepoEntry}; @@ -32,6 +32,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> { Commands::View(args) => run_view(args).await, Commands::Config(cmd) => run_config(cmd).await, Commands::Chain(cmd) => run_chain(cmd).await, + Commands::Directive(cmd) => run_directive(cmd).await, } } @@ -1021,6 +1022,154 @@ async fn run_chain( Ok(()) } +/// Run directive commands. +async fn run_directive( + cmd: DirectiveCommand, +) -> Result<(), Box<dyn std::error::Error + Send + Sync>> { + match cmd { + DirectiveCommand::Create(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + let result = client + .create_directive(&args.goal, args.repository.as_deref(), &args.autonomy) + .await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Status(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + let result = client.get_directive(args.directive_id).await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::List(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + let result = client + .list_directives(args.status.as_deref(), args.limit) + .await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Steps(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + let result = client.get_directive_chain(args.directive_id).await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Graph(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + let result = client.get_directive_graph(args.directive_id).await?; + + if args.with_status { + // Enhanced ASCII visualization with status + if let Some(nodes) = result.0.get("nodes").and_then(|v| v.as_array()) { + let mut by_depth: std::collections::HashMap<i32, Vec<(&str, &str)>> = + std::collections::HashMap::new(); + + for node in nodes { + let name = node.get("name").and_then(|v| v.as_str()).unwrap_or("?"); + let status = node + .get("status") + .and_then(|v| v.as_str()) + .unwrap_or("pending"); + let depth = node.get("depth").and_then(|v| v.as_i64()).unwrap_or(0) as i32; + by_depth.entry(depth).or_default().push((name, status)); + } + + let directive_name = result + .0 + .get("name") + .and_then(|v| v.as_str()) + .unwrap_or("Directive"); + println!("Directive: {}", directive_name); + println!(); + + let max_depth = by_depth.keys().max().copied().unwrap_or(0); + for depth in 0..=max_depth { + if let Some(steps) = by_depth.get(&depth) { + let indent = " ".repeat(depth as usize); + for (name, status) in steps { + let status_icon = match *status { + "passed" | "completed" => "\u{2713}", + "running" | "evaluating" => "\u{21bb}", + "failed" | "blocked" => "\u{2717}", + "rework" => "\u{21ba}", + "skipped" => "\u{2212}", + "ready" => "\u{25b7}", + _ => "\u{25cb}", + }; + println!("{}[{}] {} {}", indent, name, status_icon, status); + } + if depth < max_depth { + println!("{} |", indent); + println!("{} v", indent); + } + } + } + } + } else { + println!("{}", serde_json::to_string_pretty(&result.0)?); + } + } + DirectiveCommand::Events(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + let result = client + .list_directive_events(args.directive_id, args.limit) + .await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Approve(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + let result = client + .approve_directive_request( + args.directive_id, + args.approval_id, + args.response.as_deref(), + ) + .await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Deny(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + let result = client + .deny_directive_request( + args.directive_id, + args.approval_id, + args.reason.as_deref(), + ) + .await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Start(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + eprintln!("Starting directive {}...", args.directive_id); + let result = client.start_directive(args.directive_id).await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Pause(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + eprintln!("Pausing directive {}...", args.directive_id); + let result = client.pause_directive(args.directive_id).await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Resume(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + eprintln!("Resuming directive {}...", args.directive_id); + let result = client.resume_directive(args.directive_id).await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Stop(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + eprintln!("Stopping directive {}...", args.directive_id); + let result = client.stop_directive(args.directive_id).await?; + println!("{}", serde_json::to_string(&result.0)?); + } + DirectiveCommand::Archive(args) => { + let client = ApiClient::new(args.common.api_url, args.common.api_key)?; + eprintln!("Archiving directive {}...", args.directive_id); + let result = client.archive_directive(args.directive_id).await?; + println!("{}", serde_json::to_string(&result.0)?); + } + } + + Ok(()) +} + /// Load contracts from API async fn load_contracts(client: &ApiClient) -> Result<Vec<ListItem>, Box<dyn std::error::Error + Send + Sync>> { let result = client.list_contracts().await?; diff --git a/makima/src/daemon/api/directive.rs b/makima/src/daemon/api/directive.rs new file mode 100644 index 0000000..5281d21 --- /dev/null +++ b/makima/src/daemon/api/directive.rs @@ -0,0 +1,162 @@ +//! Directive API methods. + +use uuid::Uuid; + +use super::client::{ApiClient, ApiError}; +use super::supervisor::JsonValue; + +impl ApiClient { + /// Create a new directive. + pub async fn create_directive( + &self, + goal: &str, + repository_url: Option<&str>, + autonomy_level: &str, + ) -> Result<JsonValue, ApiError> { + #[derive(serde::Serialize)] + #[serde(rename_all = "camelCase")] + struct CreateRequest<'a> { + goal: &'a str, + repository_url: Option<&'a str>, + autonomy_level: &'a str, + } + let req = CreateRequest { + goal, + repository_url, + autonomy_level, + }; + self.post("/api/v1/directives", &req).await + } + + /// List all directives for the authenticated user. + pub async fn list_directives( + &self, + status: Option<&str>, + limit: i32, + ) -> Result<JsonValue, ApiError> { + let mut params = Vec::new(); + if let Some(s) = status { + params.push(format!("status={}", s)); + } + params.push(format!("limit={}", limit)); + let query_string = format!("?{}", params.join("&")); + self.get(&format!("/api/v1/directives{}", query_string)) + .await + } + + /// Get a directive by ID (includes progress info). + pub async fn get_directive(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> { + self.get(&format!("/api/v1/directives/{}", directive_id)) + .await + } + + /// Archive a directive. + pub async fn archive_directive(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> { + self.delete_with_response(&format!("/api/v1/directives/{}", directive_id)) + .await + } + + /// Start a directive (plans and begins execution). + pub async fn start_directive(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> { + self.post_empty(&format!("/api/v1/directives/{}/start", directive_id)) + .await + } + + /// Pause a directive. + pub async fn pause_directive(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> { + self.post_empty(&format!("/api/v1/directives/{}/pause", directive_id)) + .await + } + + /// Resume a paused directive. + pub async fn resume_directive(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> { + self.post_empty(&format!("/api/v1/directives/{}/resume", directive_id)) + .await + } + + /// Stop a directive. + pub async fn stop_directive(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> { + self.post_empty(&format!("/api/v1/directives/{}/stop", directive_id)) + .await + } + + /// Get the current chain and steps for a directive. + pub async fn get_directive_chain(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> { + self.get(&format!("/api/v1/directives/{}/chain", directive_id)) + .await + } + + /// Get directive DAG structure for visualization. + pub async fn get_directive_graph(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> { + self.get(&format!("/api/v1/directives/{}/chain/graph", directive_id)) + .await + } + + /// List events for a directive. + pub async fn list_directive_events( + &self, + directive_id: Uuid, + limit: i32, + ) -> Result<JsonValue, ApiError> { + self.get(&format!( + "/api/v1/directives/{}/events?limit={}", + directive_id, limit + )) + .await + } + + /// List pending approvals for a directive. + pub async fn list_directive_approvals( + &self, + directive_id: Uuid, + ) -> Result<JsonValue, ApiError> { + self.get(&format!("/api/v1/directives/{}/approvals", directive_id)) + .await + } + + /// Approve an approval request. + pub async fn approve_directive_request( + &self, + directive_id: Uuid, + approval_id: Uuid, + response: Option<&str>, + ) -> Result<JsonValue, ApiError> { + #[derive(serde::Serialize)] + #[serde(rename_all = "camelCase")] + struct ApprovalRequest<'a> { + response: Option<&'a str>, + } + let req = ApprovalRequest { response }; + self.post( + &format!( + "/api/v1/directives/{}/approvals/{}/approve", + directive_id, approval_id + ), + &req, + ) + .await + } + + /// Deny an approval request. + pub async fn deny_directive_request( + &self, + directive_id: Uuid, + approval_id: Uuid, + response: Option<&str>, + ) -> Result<JsonValue, ApiError> { + #[derive(serde::Serialize)] + #[serde(rename_all = "camelCase")] + struct ApprovalRequest<'a> { + response: Option<&'a str>, + } + let req = ApprovalRequest { response }; + self.post( + &format!( + "/api/v1/directives/{}/approvals/{}/deny", + directive_id, approval_id + ), + &req, + ) + .await + } +} diff --git a/makima/src/daemon/api/mod.rs b/makima/src/daemon/api/mod.rs index 7868907..f1f52d0 100644 --- a/makima/src/daemon/api/mod.rs +++ b/makima/src/daemon/api/mod.rs @@ -3,6 +3,7 @@ pub mod chain; pub mod client; pub mod contract; +pub mod directive; pub mod supervisor; pub use client::ApiClient; diff --git a/makima/src/daemon/chain/parser.rs b/makima/src/daemon/chain/parser.rs index 3851d1f..b32d0f2 100644 --- a/makima/src/daemon/chain/parser.rs +++ b/makima/src/daemon/chain/parser.rs @@ -395,7 +395,9 @@ contracts: fn test_repo_alias() { let yaml = r#" name: Repo Chain -repo: https://github.com/user/project +repositories: + - name: main + repository_url: https://github.com/user/project contracts: - name: Phase1 tasks: @@ -403,8 +405,9 @@ contracts: plan: "Work on repo" "#; let chain = parse_chain_yaml(yaml).unwrap(); + assert_eq!(chain.repositories.len(), 1); assert_eq!( - chain.repository_url, + chain.repositories[0].repository_url, Some("https://github.com/user/project".to_string()) ); } diff --git a/makima/src/daemon/chain/runner.rs b/makima/src/daemon/chain/runner.rs index dfbcfa7..1814581 100644 --- a/makima/src/daemon/chain/runner.rs +++ b/makima/src/daemon/chain/runner.rs @@ -37,8 +37,10 @@ pub enum RunnerError { /// Chain runner for creating and managing chains. pub struct ChainRunner { /// Base API URL + #[allow(dead_code)] api_url: String, /// API key for authentication + #[allow(dead_code)] api_key: String, } @@ -116,6 +118,7 @@ impl ChainRunner { CreateChainRequest { name: chain.name.clone(), description: chain.description.clone(), + repository_url: None, // Legacy field, repositories take precedence repositories: if repositories.is_empty() { None } else { @@ -242,7 +245,9 @@ mod tests { let yaml = r#" name: Test Chain description: A test chain -repo: https://github.com/test/repo +repositories: + - name: main + repository_url: https://github.com/test/repo contracts: - name: Research type: simple @@ -270,8 +275,11 @@ loop: assert_eq!(request.name, "Test Chain"); assert_eq!(request.description, Some("A test chain".to_string())); + // Repositories are now in a separate array + let repos = request.repositories.unwrap(); + assert_eq!(repos.len(), 1); assert_eq!( - request.repository_url, + repos[0].repository_url, Some("https://github.com/test/repo".to_string()) ); assert_eq!(request.loop_enabled, Some(true)); diff --git a/makima/src/daemon/cli/directive.rs b/makima/src/daemon/cli/directive.rs new file mode 100644 index 0000000..a2bb34b --- /dev/null +++ b/makima/src/daemon/cli/directive.rs @@ -0,0 +1,186 @@ +//! Directive CLI commands for autonomous goal-driven orchestration. +//! +//! Directives are top-level goals that the system works toward. Each directive +//! generates a chain of steps that are executed autonomously with configurable +//! guardrails. + +use clap::Args; +use uuid::Uuid; + +/// Common arguments for directive commands requiring API access. +#[derive(Args, Debug, Clone)] +pub struct DirectiveArgs { + /// API URL + #[arg(long, env = "MAKIMA_API_URL", default_value = "https://api.makima.jp", global = true)] + pub api_url: String, + + /// API key for authentication + #[arg(long, env = "MAKIMA_API_KEY", global = true)] + pub api_key: String, +} + +/// Arguments for the `create` command. +#[derive(Args, Debug)] +pub struct CreateArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// The goal for the directive + #[arg(short, long)] + pub goal: String, + + /// Repository URL (optional) + #[arg(short, long)] + pub repository: Option<String>, + + /// Autonomy level: full_auto, guardrails, or manual + #[arg(short, long, default_value = "guardrails")] + pub autonomy: String, +} + +/// Arguments for the `status` command. +#[derive(Args, Debug)] +pub struct StatusArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, +} + +/// Arguments for the `list` command. +#[derive(Args, Debug)] +pub struct ListArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Filter by status (draft, planning, active, paused, completed, archived, failed) + #[arg(long)] + pub status: Option<String>, + + /// Limit number of results + #[arg(long, default_value = "50")] + pub limit: i32, +} + +/// Arguments for the `steps` command. +#[derive(Args, Debug)] +pub struct StepsArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, +} + +/// Arguments for the `events` command. +#[derive(Args, Debug)] +pub struct EventsArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, + + /// Limit number of events + #[arg(long, default_value = "50")] + pub limit: i32, +} + +/// Arguments for the `approve` command. +#[derive(Args, Debug)] +pub struct ApproveArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, + + /// Approval ID + pub approval_id: Uuid, + + /// Response message (optional) + #[arg(short, long)] + pub response: Option<String>, +} + +/// Arguments for the `deny` command. +#[derive(Args, Debug)] +pub struct DenyArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, + + /// Approval ID + pub approval_id: Uuid, + + /// Reason for denial (optional) + #[arg(short, long)] + pub reason: Option<String>, +} + +/// Arguments for the `start` command. +#[derive(Args, Debug)] +pub struct StartArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, +} + +/// Arguments for the `pause` command. +#[derive(Args, Debug)] +pub struct PauseArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, +} + +/// Arguments for the `resume` command. +#[derive(Args, Debug)] +pub struct ResumeArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, +} + +/// Arguments for the `stop` command. +#[derive(Args, Debug)] +pub struct StopArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, +} + +/// Arguments for the `archive` command. +#[derive(Args, Debug)] +pub struct ArchiveArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, +} + +/// Arguments for the `graph` command (ASCII DAG visualization). +#[derive(Args, Debug)] +pub struct GraphArgs { + #[command(flatten)] + pub common: DirectiveArgs, + + /// Directive ID + pub directive_id: Uuid, + + /// Show step status in nodes + #[arg(long)] + pub with_status: bool, +} diff --git a/makima/src/daemon/cli/mod.rs b/makima/src/daemon/cli/mod.rs index 035a784..91ef87c 100644 --- a/makima/src/daemon/cli/mod.rs +++ b/makima/src/daemon/cli/mod.rs @@ -4,6 +4,7 @@ pub mod chain; pub mod config; pub mod contract; pub mod daemon; +pub mod directive; pub mod server; pub mod supervisor; pub mod view; @@ -14,6 +15,7 @@ pub use chain::ChainArgs; pub use config::CliConfig; pub use contract::ContractArgs; pub use daemon::DaemonArgs; +pub use directive::DirectiveArgs; pub use server::ServerArgs; pub use supervisor::SupervisorArgs; pub use view::ViewArgs; @@ -68,6 +70,14 @@ pub enum Commands { /// in parallel when no dependencies exist. #[command(subcommand)] Chain(ChainCommand), + + /// Directive commands for autonomous goal-driven orchestration + /// + /// Directives are top-level goals that generate chains of steps executed + /// autonomously with configurable guardrails. Steps spawn contracts with + /// supervisors and are verified with programmatic and LLM evaluation. + #[command(subcommand)] + Directive(DirectiveCommand), } /// Config subcommands for CLI configuration. @@ -248,6 +258,52 @@ pub enum ChainCommand { Archive(chain::ArchiveArgs), } +/// Directive subcommands for autonomous goal-driven orchestration. +#[derive(Subcommand, Debug)] +pub enum DirectiveCommand { + /// Create a new directive from a goal + Create(directive::CreateArgs), + + /// Get directive status and progress + Status(directive::StatusArgs), + + /// List all directives + List(directive::ListArgs), + + /// List steps in the directive's chain + Steps(directive::StepsArgs), + + /// Display ASCII DAG visualization + /// + /// Shows the directive's chain structure as an ASCII graph with + /// steps as nodes and dependencies as edges. + Graph(directive::GraphArgs), + + /// Show recent events for a directive + Events(directive::EventsArgs), + + /// Approve a pending approval request + Approve(directive::ApproveArgs), + + /// Deny a pending approval request + Deny(directive::DenyArgs), + + /// Start a directive (generates chain and begins execution) + Start(directive::StartArgs), + + /// Pause a running directive + Pause(directive::PauseArgs), + + /// Resume a paused directive + Resume(directive::ResumeArgs), + + /// Stop a directive + Stop(directive::StopArgs), + + /// Archive a directive + Archive(directive::ArchiveArgs), +} + impl Cli { /// Parse command-line arguments pub fn parse_args() -> Self { diff --git a/makima/src/daemon/db/local.rs b/makima/src/daemon/db/local.rs index f3ed45a..5b4ca5b 100644 --- a/makima/src/daemon/db/local.rs +++ b/makima/src/daemon/db/local.rs @@ -336,7 +336,9 @@ impl LocalDb { #[cfg(test)] mod tests { - use crate::daemon::*; + use super::*; + use chrono::Utc; + use uuid::Uuid; #[test] fn test_open_memory() { diff --git a/makima/src/daemon/process/claude_protocol.rs b/makima/src/daemon/process/claude_protocol.rs index 96e5377..930152b 100644 --- a/makima/src/daemon/process/claude_protocol.rs +++ b/makima/src/daemon/process/claude_protocol.rs @@ -45,7 +45,7 @@ impl ClaudeInputMessage { #[cfg(test)] mod tests { - use crate::daemon::*; + use super::*; #[test] fn test_user_message_serialization() { diff --git a/makima/src/daemon/skills/directive.md b/makima/src/daemon/skills/directive.md new file mode 100644 index 0000000..97e8e20 --- /dev/null +++ b/makima/src/daemon/skills/directive.md @@ -0,0 +1,303 @@ +--- +name: makima-directive +description: Directive orchestration tools for autonomous goal-driven execution. Use when working with directives, chains, steps, verifiers, and approvals. +--- + +# Directive Orchestration Tools + +Directives are top-level goals that drive autonomous execution with configurable guardrails. Each directive generates a chain of steps that spawn contracts with supervisors, verified by programmatic checks and LLM evaluation. + +## Architecture + +``` +Directive (goal + requirements + acceptance criteria) + | + +-- Chain (generated DAG execution plan) + | +-- Step 1 (pending -> ready -> running -> evaluating -> passed) + | | +-- Contract (spawned when step reaches 'ready') + | | +-- Supervisor Task + | +-- Step 2 (depends_on: [Step 1]) + | +-- Step 3 (depends_on: [Step 1], parallel with Step 2) + | + +-- Verifiers (test runner, linter, build, type checker) + +-- Evaluations (programmatic + LLM composite scores) + +-- Events (audit stream) + +-- Approvals (human-in-the-loop gates) +``` + +## Status Flow + +### Directive Status +- `draft` - Created but not started +- `planning` - Generating chain from requirements +- `active` - Executing steps +- `paused` - Temporarily stopped +- `completed` - All steps passed +- `archived` - No longer active +- `failed` - Execution failed + +### Step Status +- `pending` - Waiting for dependencies +- `ready` - Dependencies met, ready to start +- `running` - Contract executing +- `evaluating` - Running verifiers +- `passed` - Evaluation succeeded +- `failed` - Evaluation failed, exceeded retries +- `rework` - Sent back for corrections +- `skipped` - Manually skipped +- `blocked` - Blocked by failed dependency + +## Autonomy Levels + +- `full_auto` - No approval gates, automatic progression +- `guardrails` - Request approval for yellow/red confidence scores +- `manual` - Request approval for all step completions + +## Confidence Scoring + +Each step evaluation produces a composite confidence score: + +1. **Programmatic verifiers** run first (tests, lint, build) + - Weight: 1.0 each + - If any required verifier fails: automatic RED + +2. **LLM evaluation** runs second + - Weight: 2.0 + - Evaluates against acceptance criteria + +3. **Composite score** computed from weighted average + - GREEN: >= configured threshold (default 0.8) + - YELLOW: >= yellow threshold (default 0.5) + - RED: below yellow threshold + +## CLI Commands + +```bash +# Create a new directive +makima directive create --goal "Add OAuth2 authentication" --repository https://github.com/org/repo + +# List directives +makima directive list [--status active] + +# Get directive status with progress +makima directive status <directive-id> + +# Start execution (generates chain and begins) +makima directive start <directive-id> + +# View chain steps +makima directive steps <directive-id> + +# View DAG visualization +makima directive graph <directive-id> --with-status + +# View recent events +makima directive events <directive-id> --limit 20 + +# Approve a pending request +makima directive approve <directive-id> <approval-id> [--response "Looks good"] + +# Deny a pending request +makima directive deny <directive-id> <approval-id> [--reason "Need more testing"] + +# Lifecycle commands +makima directive pause <directive-id> +makima directive resume <directive-id> +makima directive stop <directive-id> +makima directive archive <directive-id> +``` + +## API Endpoints + +### Directive CRUD +``` +POST /api/v1/directives # Create from goal +GET /api/v1/directives # List +GET /api/v1/directives/:id # Get with progress +PUT /api/v1/directives/:id # Update +DELETE /api/v1/directives/:id # Archive +``` + +### Lifecycle +``` +POST /api/v1/directives/:id/start # Plan + execute +POST /api/v1/directives/:id/pause # Pause +POST /api/v1/directives/:id/resume # Resume +POST /api/v1/directives/:id/stop # Stop +``` + +### Chain & Steps +``` +GET /api/v1/directives/:id/chain # Current chain + steps +GET /api/v1/directives/:id/chain/graph # DAG for visualization +POST /api/v1/directives/:id/chain/replan # Force regeneration +POST /api/v1/directives/:id/chain/steps # Add step +PUT /api/v1/directives/:id/chain/steps/:sid # Modify step +DELETE /api/v1/directives/:id/chain/steps/:sid # Remove step +``` + +### Step Operations +``` +GET /api/v1/directives/:id/steps/:sid # Step detail +POST /api/v1/directives/:id/steps/:sid/evaluate # Force re-evaluation +POST /api/v1/directives/:id/steps/:sid/skip # Skip step +POST /api/v1/directives/:id/steps/:sid/rework # Manual rework +``` + +### Monitoring +``` +GET /api/v1/directives/:id/evaluations # List evaluations +GET /api/v1/directives/:id/events # Event log (polling) +GET /api/v1/directives/:id/events/stream # Event stream (SSE) +``` + +### Verifiers +``` +GET /api/v1/directives/:id/verifiers # List verifiers +POST /api/v1/directives/:id/verifiers # Add verifier +PUT /api/v1/directives/:id/verifiers/:vid # Update verifier +POST /api/v1/directives/:id/verifiers/auto-detect # Auto-detect +``` + +### Approvals +``` +GET /api/v1/directives/:id/approvals # Pending approvals +POST /api/v1/directives/:id/approvals/:aid/approve # Approve +POST /api/v1/directives/:id/approvals/:aid/deny # Deny +``` + +## Creating a Directive + +### Request +```json +POST /api/v1/directives +{ + "goal": "Implement user authentication with OAuth2", + "repositoryUrl": "https://github.com/org/repo", + "autonomyLevel": "guardrails", + "confidenceThresholdGreen": 0.8, + "confidenceThresholdYellow": 0.5, + "maxReworkCycles": 3, + "maxTotalCostUsd": 100.0, + "maxWallTimeMinutes": 480 +} +``` + +### Response +```json +{ + "id": "uuid", + "title": "Implement user authentication with OAuth2", + "goal": "Implement user authentication with OAuth2", + "status": "draft", + "autonomyLevel": "guardrails", + "createdAt": "2026-02-05T12:00:00Z" +} +``` + +## Starting a Directive + +When you start a directive: +1. System generates requirements from the goal +2. Chain planner creates a DAG of steps +3. Root steps (no dependencies) transition to `ready` +4. Contracts spawn for ready steps with supervisors +5. Verifiers auto-detect from repository + +## Evaluation Flow + +When a contract completes: + +1. Step transitions to `evaluating` +2. **Programmatic verifiers** run (tests, lint, build) + - Each produces pass/fail + output +3. **LLM evaluation** runs + - Reviews code against acceptance criteria + - Provides feedback and score +4. **Composite score** computed +5. Based on confidence level and autonomy: + - GREEN: Step passes, downstream unblocks + - YELLOW (guardrails): Request approval + - RED: Initiate rework or request approval + +## Rework Flow + +When a step needs rework: + +1. Contract phase reset to editing +2. Supervisor receives rework instructions +3. Rework count incremented +4. If max reworks exceeded: escalate or fail + +## Event Types + +Events are logged for audit and monitoring: + +- `directive_created`, `directive_started`, `directive_paused`, `directive_completed` +- `chain_generated`, `chain_regenerated` +- `step_ready`, `step_started`, `step_evaluating`, `step_passed`, `step_failed` +- `rework_initiated`, `rework_completed` +- `approval_requested`, `approval_granted`, `approval_denied` +- `verifier_run`, `evaluation_completed` +- `circuit_breaker_triggered` + +## Verifier Configuration + +Verifiers can be auto-detected or manually configured: + +```json +POST /api/v1/directives/:id/verifiers +{ + "name": "Test Runner", + "verifierType": "test_runner", + "command": "npm test", + "workingDirectory": ".", + "timeoutSeconds": 300, + "weight": 1.0, + "required": true, + "enabled": true +} +``` + +### Auto-Detection + +The system detects verifiers from: +- `package.json` - npm test, npm run lint, npm run build +- `Cargo.toml` - cargo test, cargo clippy, cargo build +- `pyproject.toml` - pytest, ruff, mypy + +## Circuit Breakers + +Directives have built-in circuit breakers: + +- `maxTotalCostUsd` - Stop if cumulative cost exceeds limit +- `maxWallTimeMinutes` - Stop if elapsed time exceeds limit +- `maxReworkCycles` - Fail step after N rework attempts +- `maxChainRegenerations` - Fail if chain regenerated too many times + +## Example Workflow + +```bash +# 1. Create a directive +makima directive create \ + --goal "Add dark mode to the application" \ + --repository https://github.com/myorg/myapp \ + --autonomy guardrails + +# Returns directive ID: 123e4567-e89b-12d3-a456-426614174000 + +# 2. Start execution +makima directive start 123e4567-e89b-12d3-a456-426614174000 + +# 3. Monitor progress +makima directive status 123e4567-e89b-12d3-a456-426614174000 + +# 4. View the execution graph +makima directive graph 123e4567-e89b-12d3-a456-426614174000 --with-status + +# 5. Watch events +makima directive events 123e4567-e89b-12d3-a456-426614174000 + +# 6. If approval needed, approve or deny +makima directive approve 123e4567-e89b-12d3-a456-426614174000 <approval-id> +``` diff --git a/makima/src/daemon/skills/mod.rs b/makima/src/daemon/skills/mod.rs index 3b0c0dc..dafa9ec 100644 --- a/makima/src/daemon/skills/mod.rs +++ b/makima/src/daemon/skills/mod.rs @@ -9,12 +9,16 @@ pub const SUPERVISOR_SKILL: &str = include_str!("supervisor.md"); /// Contract skill content - task-contract interaction commands pub const CONTRACT_SKILL: &str = include_str!("contract.md"); -/// Chain skill content - multi-contract orchestration commands +/// Chain skill content - multi-contract orchestration commands (legacy) pub const CHAIN_SKILL: &str = include_str!("chain.md"); +/// Directive skill content - autonomous goal-driven orchestration +pub const DIRECTIVE_SKILL: &str = include_str!("directive.md"); + /// All skills as (name, content) pairs for installation pub const ALL_SKILLS: &[(&str, &str)] = &[ ("makima-supervisor", SUPERVISOR_SKILL), ("makima-contract", CONTRACT_SKILL), ("makima-chain", CHAIN_SKILL), + ("makima-directive", DIRECTIVE_SKILL), ]; diff --git a/makima/src/daemon/storage/patch.rs b/makima/src/daemon/storage/patch.rs index 0da4eda..b374d15 100644 --- a/makima/src/daemon/storage/patch.rs +++ b/makima/src/daemon/storage/patch.rs @@ -227,6 +227,16 @@ pub async fn create_export_patch( None }; + // Get current HEAD SHA for comparison + let head_sha = Command::new("git") + .current_dir(worktree_path) + .args(["rev-parse", "HEAD"]) + .output() + .await + .ok() + .filter(|o| o.status.success()) + .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string()); + // If we couldn't find upstream, try common default branches let base = if base.is_none() { let default_branches = ["origin/main", "origin/master", "main", "master"]; @@ -241,14 +251,23 @@ pub async fn create_export_patch( if let Ok(output) = merge_base { if output.status.success() { - found_base = Some(String::from_utf8_lossy(&output.stdout).trim().to_string()); - break; + let mb_sha = String::from_utf8_lossy(&output.stdout).trim().to_string(); + // Skip if merge-base equals HEAD (would result in empty diff) + if head_sha.as_ref() != Some(&mb_sha) { + found_base = Some(mb_sha); + break; + } } } } found_base } else { - base + // Also check upstream base + if base.as_ref() == head_sha.as_ref() { + None + } else { + base + } }; // If still nothing, get the first commit or use HEAD~1 diff --git a/makima/src/daemon/task/completion_gate.rs b/makima/src/daemon/task/completion_gate.rs index 69b7c6a..40a6466 100644 --- a/makima/src/daemon/task/completion_gate.rs +++ b/makima/src/daemon/task/completion_gate.rs @@ -5,7 +5,7 @@ //! development framework. //! //! Format: -//! ``` +//! ```text //! <COMPLETION_GATE> //! ready: true|false //! reason: "explanation of completion status" @@ -133,19 +133,18 @@ impl CompletionGate { /// This is useful when Claude produces multiple completion gates during /// a long-running task, and we want to use the final status. pub fn parse_last(text: &str) -> Option<Self> { + let start_tag = "<COMPLETION_GATE>"; let end_tag = "</COMPLETION_GATE>"; - let mut last_gate = None; - let mut search_start = 0; - while let Some(end_idx) = text[search_start..].find(end_tag) { - let absolute_end = search_start + end_idx + end_tag.len(); - if let Some(gate) = Self::parse(&text[..absolute_end]) { - last_gate = Some(gate); - } - search_start = absolute_end; - } + // Find the last occurrence of the start tag + let start_idx = text.rfind(start_tag)?; + let remaining = &text[start_idx..]; + + // Find the end tag after the last start tag + let end_idx = remaining.find(end_tag)?; - last_gate + // Parse just this last gate + Self::parse(&remaining[..end_idx + end_tag.len()]) } } diff --git a/makima/src/daemon/task/state.rs b/makima/src/daemon/task/state.rs index 7b59b62..fe73de1 100644 --- a/makima/src/daemon/task/state.rs +++ b/makima/src/daemon/task/state.rs @@ -124,9 +124,7 @@ impl Default for TaskState { #[cfg(test)] mod tests { - #[allow(unused_imports)] - use crate::daemon::*; - use super::TaskState; + use super::*; #[test] fn test_valid_transitions() { diff --git a/makima/src/daemon/temp.rs b/makima/src/daemon/temp.rs index 42d4a28..015b21b 100644 --- a/makima/src/daemon/temp.rs +++ b/makima/src/daemon/temp.rs @@ -214,7 +214,7 @@ impl Default for TempManager { #[cfg(test)] mod tests { - use crate::daemon::*; + use super::*; #[test] fn test_temp_manager_default_dir() { diff --git a/makima/src/daemon/worktree/manager.rs b/makima/src/daemon/worktree/manager.rs index 166e654..310627c 100644 --- a/makima/src/daemon/worktree/manager.rs +++ b/makima/src/daemon/worktree/manager.rs @@ -1949,7 +1949,8 @@ pub fn sanitize_name(name: &str) -> String { #[cfg(test)] mod tests { - use crate::daemon::*; + use super::*; + use uuid::Uuid; #[test] fn test_extract_repo_name() { diff --git a/makima/src/daemon/ws/protocol.rs b/makima/src/daemon/ws/protocol.rs index 5c88038..574e864 100644 --- a/makima/src/daemon/ws/protocol.rs +++ b/makima/src/daemon/ws/protocol.rs @@ -907,7 +907,7 @@ impl DaemonMessage { #[cfg(test)] mod tests { - use crate::daemon::*; + use super::*; #[test] fn test_daemon_message_serialization() { @@ -920,7 +920,7 @@ mod tests { #[test] fn test_daemon_command_deserialization() { - let json = r#"{"type":"spawnTask","taskId":"550e8400-e29b-41d4-a716-446655440000","plan":"Build the feature","repoUrl":"https://github.com/test/repo","baseBranch":"main","parentTaskId":null,"depth":0,"isOrchestrator":false}"#; + let json = r#"{"type":"spawnTask","taskId":"550e8400-e29b-41d4-a716-446655440000","taskName":"Build Feature","plan":"Build the feature","repoUrl":"https://github.com/test/repo","baseBranch":"main","parentTaskId":null,"depth":0,"isOrchestrator":false}"#; let cmd: DaemonCommand = serde_json::from_str(json).unwrap(); match cmd { DaemonCommand::SpawnTask { @@ -945,7 +945,7 @@ mod tests { #[test] fn test_orchestrator_spawn_deserialization() { - let json = r#"{"type":"spawnTask","taskId":"550e8400-e29b-41d4-a716-446655440000","plan":"Coordinate subtasks","repoUrl":"https://github.com/test/repo","baseBranch":"main","parentTaskId":null,"depth":0,"isOrchestrator":true}"#; + let json = r#"{"type":"spawnTask","taskId":"550e8400-e29b-41d4-a716-446655440000","taskName":"Coordinate","plan":"Coordinate subtasks","repoUrl":"https://github.com/test/repo","baseBranch":"main","parentTaskId":null,"depth":0,"isOrchestrator":true}"#; let cmd: DaemonCommand = serde_json::from_str(json).unwrap(); match cmd { DaemonCommand::SpawnTask { diff --git a/makima/src/db/models.rs b/makima/src/db/models.rs index e861f1d..3a96165 100644 --- a/makima/src/db/models.rs +++ b/makima/src/db/models.rs @@ -1446,16 +1446,16 @@ pub struct Contract { /// Use `get_phase_config()` to get the parsed PhaseConfig. #[serde(skip_serializing_if = "Option::is_none")] pub phase_config: Option<serde_json::Value>, - /// Chain ID if this contract is part of a chain (DAG of contracts) + /// Directive ID if this contract is part of a directive's chain #[serde(skip_serializing_if = "Option::is_none")] - pub chain_id: Option<Uuid>, - /// Reference to chain spawned by this directive contract - #[serde(skip_serializing_if = "Option::is_none")] - pub spawned_chain_id: Option<Uuid>, - /// Whether this contract is a chain directive orchestrator + pub directive_id: Option<Uuid>, + /// Whether this contract is a directive orchestrator #[serde(default)] #[sqlx(default)] - pub is_chain_directive: bool, + pub is_directive_orchestrator: bool, + /// Reference to directive spawned by this orchestrator contract + #[serde(skip_serializing_if = "Option::is_none")] + pub spawned_directive_id: Option<Uuid>, pub version: i32, pub created_at: DateTime<Utc>, pub updated_at: DateTime<Utc>, @@ -2596,914 +2596,648 @@ pub struct HeartbeatHistoryQuery { } // ============================================================================= -// Chains (DAG of contracts for multi-contract orchestration) +// Directives (Goal-driven orchestration with chains of steps) // ============================================================================= -/// Chain status determines the overall state of the chain +/// Directive status #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "lowercase")] -pub enum ChainStatus { - /// Chain is actively running +#[serde(rename_all = "snake_case")] +pub enum DirectiveStatus { + Draft, + Planning, Active, - /// All contracts completed successfully + Paused, Completed, - /// Chain was manually archived Archived, + Failed, } -impl Default for ChainStatus { +impl Default for DirectiveStatus { fn default() -> Self { - ChainStatus::Active + DirectiveStatus::Draft } } -impl std::fmt::Display for ChainStatus { +impl std::fmt::Display for DirectiveStatus { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - ChainStatus::Active => write!(f, "active"), - ChainStatus::Completed => write!(f, "completed"), - ChainStatus::Archived => write!(f, "archived"), + DirectiveStatus::Draft => write!(f, "draft"), + DirectiveStatus::Planning => write!(f, "planning"), + DirectiveStatus::Active => write!(f, "active"), + DirectiveStatus::Paused => write!(f, "paused"), + DirectiveStatus::Completed => write!(f, "completed"), + DirectiveStatus::Archived => write!(f, "archived"), + DirectiveStatus::Failed => write!(f, "failed"), } } } -impl std::str::FromStr for ChainStatus { +impl std::str::FromStr for DirectiveStatus { type Err = String; fn from_str(s: &str) -> Result<Self, Self::Err> { match s.to_lowercase().as_str() { - "active" => Ok(ChainStatus::Active), - "completed" => Ok(ChainStatus::Completed), - "archived" => Ok(ChainStatus::Archived), - _ => Err(format!("Invalid chain status: {}", s)), + "draft" => Ok(DirectiveStatus::Draft), + "planning" => Ok(DirectiveStatus::Planning), + "active" => Ok(DirectiveStatus::Active), + "paused" => Ok(DirectiveStatus::Paused), + "completed" => Ok(DirectiveStatus::Completed), + "archived" => Ok(DirectiveStatus::Archived), + "failed" => Ok(DirectiveStatus::Failed), + _ => Err(format!("Invalid directive status: {}", s)), } } } -/// Chain - a directed acyclic graph (DAG) of contracts -/// Fits Makima's control theme - she controls through invisible chains +/// Directive - the top-level goal-driven orchestration entity #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct Chain { +pub struct Directive { pub id: Uuid, pub owner_id: Uuid, - pub name: String, - pub description: Option<String>, + pub title: String, + pub goal: String, + /// Structured requirements: [{ id, title, description, priority, category }] + #[sqlx(json)] + pub requirements: serde_json::Value, + /// Acceptance criteria: [{ id, requirementIds, description, testable, verificationMethod }] + #[sqlx(json)] + pub acceptance_criteria: serde_json::Value, + /// Constraints: [{ id, type, description, impact }] + #[sqlx(json)] + pub constraints: serde_json::Value, + /// External dependencies: [{ id, name, type, status, requiredBy }] + #[sqlx(json)] + pub external_dependencies: serde_json::Value, pub status: String, - /// Whether loop mode is enabled for iterative execution - #[serde(default)] - pub loop_enabled: bool, - /// Maximum loop iterations (default: 10) - pub loop_max_iterations: Option<i32>, - /// Current loop iteration count - pub loop_current_iteration: Option<i32>, - /// Progress check prompt/criteria for evaluating loop completion - pub loop_progress_check: Option<String>, - /// Reference to the directive contract that created/orchestrates this chain - pub directive_contract_id: Option<Uuid>, - /// The directive document text (formal specification) - pub directive_document: Option<String>, - /// Whether LLM evaluation is enabled after contract completion - #[serde(default = "default_evaluation_enabled")] - #[sqlx(default)] - pub evaluation_enabled: bool, - /// Default pass threshold for evaluations (0.0-1.0) - pub default_pass_threshold: Option<f64>, - /// Default max retry attempts for evaluations - pub default_max_retries: Option<i32>, - /// Version for optimistic locking + pub autonomy_level: String, + pub confidence_threshold_green: f64, + pub confidence_threshold_yellow: f64, + pub max_total_cost_usd: Option<f64>, + pub max_wall_time_minutes: Option<i32>, + pub max_rework_cycles: Option<i32>, + pub max_chain_regenerations: Option<i32>, + pub repository_url: Option<String>, + pub local_path: Option<String>, + pub base_branch: Option<String>, + pub orchestrator_contract_id: Option<Uuid>, + pub current_chain_id: Option<Uuid>, + pub chain_generation_count: i32, + pub total_cost_usd: f64, + pub started_at: Option<DateTime<Utc>>, + pub completed_at: Option<DateTime<Utc>>, pub version: i32, pub created_at: DateTime<Utc>, pub updated_at: DateTime<Utc>, } -fn default_evaluation_enabled() -> bool { - true +impl Directive { + /// Parse status string to DirectiveStatus enum + pub fn status_enum(&self) -> Result<DirectiveStatus, String> { + self.status.parse() + } } -/// Chain repository record from the database +/// Directive chain - a generated execution plan (DAG) for a directive #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainRepository { +pub struct DirectiveChain { pub id: Uuid, - pub chain_id: Uuid, + pub directive_id: Uuid, + pub generation: i32, pub name: String, - pub repository_url: Option<String>, - pub local_path: Option<String>, - pub source_type: String, + pub description: Option<String>, + pub rationale: Option<String>, + pub planning_model: Option<String>, pub status: String, - pub is_primary: bool, + pub total_steps: i32, + pub completed_steps: i32, + pub failed_steps: i32, + pub current_confidence: Option<f64>, + pub started_at: Option<DateTime<Utc>>, + pub completed_at: Option<DateTime<Utc>>, + pub version: i32, pub created_at: DateTime<Utc>, pub updated_at: DateTime<Utc>, } -impl ChainRepository { - /// Parse source_type string to RepositorySourceType enum - pub fn source_type_enum(&self) -> Result<RepositorySourceType, String> { - self.source_type.parse() +/// Chain step status +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)] +#[serde(rename_all = "snake_case")] +pub enum StepStatus { + Pending, + Ready, + Running, + Evaluating, + Passed, + Failed, + Rework, + Skipped, + Blocked, +} + +impl Default for StepStatus { + fn default() -> Self { + StepStatus::Pending } +} - /// Parse status string to RepositoryStatus enum - pub fn status_enum(&self) -> Result<RepositoryStatus, String> { - self.status.parse() +impl std::fmt::Display for StepStatus { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + StepStatus::Pending => write!(f, "pending"), + StepStatus::Ready => write!(f, "ready"), + StepStatus::Running => write!(f, "running"), + StepStatus::Evaluating => write!(f, "evaluating"), + StepStatus::Passed => write!(f, "passed"), + StepStatus::Failed => write!(f, "failed"), + StepStatus::Rework => write!(f, "rework"), + StepStatus::Skipped => write!(f, "skipped"), + StepStatus::Blocked => write!(f, "blocked"), + } } } -impl Chain { - /// Parse status string to ChainStatus enum - pub fn status_enum(&self) -> Result<ChainStatus, String> { - self.status.parse() +impl std::str::FromStr for StepStatus { + type Err = String; + fn from_str(s: &str) -> Result<Self, Self::Err> { + match s.to_lowercase().as_str() { + "pending" => Ok(StepStatus::Pending), + "ready" => Ok(StepStatus::Ready), + "running" => Ok(StepStatus::Running), + "evaluating" => Ok(StepStatus::Evaluating), + "passed" => Ok(StepStatus::Passed), + "failed" => Ok(StepStatus::Failed), + "rework" => Ok(StepStatus::Rework), + "skipped" => Ok(StepStatus::Skipped), + "blocked" => Ok(StepStatus::Blocked), + _ => Err(format!("Invalid step status: {}", s)), + } } } -/// Chain contract link - links contracts to chains with DAG dependency info +/// Chain step - a node in the DAG execution plan #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainContract { +pub struct ChainStep { pub id: Uuid, pub chain_id: Uuid, - pub contract_id: Uuid, - /// Contract IDs this contract depends on (DAG edges) + pub name: String, + pub description: Option<String>, + pub step_type: String, + pub contract_type: String, + pub initial_phase: Option<String>, + pub task_plan: Option<String>, #[sqlx(default)] - pub depends_on: Vec<Uuid>, - /// Order for display/processing (topological sort order) - pub order_index: i32, - /// X position for GUI editor - pub editor_x: Option<f64>, - /// Y position for GUI editor - pub editor_y: Option<f64>, - /// Evaluation status: pending, evaluating, passed, failed, rework, escalated - #[serde(default = "default_evaluation_status")] + pub phases: Vec<String>, #[sqlx(default)] - pub evaluation_status: String, - /// Number of evaluation retry attempts - #[serde(default)] + pub depends_on: Vec<Uuid>, + pub parallel_group: Option<String>, #[sqlx(default)] - pub evaluation_retry_count: i32, - /// Maximum evaluation retry attempts (default: 3) - #[serde(default = "default_max_evaluation_retries")] + pub requirement_ids: Vec<String>, #[sqlx(default)] - pub max_evaluation_retries: i32, - /// Reference to the last evaluation result + pub acceptance_criteria_ids: Vec<String>, + #[sqlx(json)] + #[serde(default)] + pub verifier_config: serde_json::Value, + pub status: String, + pub contract_id: Option<Uuid>, + pub supervisor_task_id: Option<Uuid>, + pub confidence_score: Option<f64>, + pub confidence_level: Option<String>, + pub evaluation_count: i32, + pub rework_count: i32, pub last_evaluation_id: Option<Uuid>, - /// Rework feedback/instructions from failed evaluation - pub rework_feedback: Option<String>, - /// When rework was started - pub rework_started_at: Option<DateTime<Utc>>, - /// When contract originally completed (before rework) - pub original_completion_at: Option<DateTime<Utc>>, + pub editor_x: Option<f64>, + pub editor_y: Option<f64>, + pub order_index: i32, + pub started_at: Option<DateTime<Utc>>, + pub completed_at: Option<DateTime<Utc>>, pub created_at: DateTime<Utc>, } -fn default_evaluation_status() -> String { - "pending".to_string() +impl ChainStep { + /// Parse status string to StepStatus enum + pub fn status_enum(&self) -> Result<StepStatus, String> { + self.status.parse() + } } -fn default_max_evaluation_retries() -> i32 { - 3 +/// Confidence level (traffic light) +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)] +#[serde(rename_all = "snake_case")] +pub enum ConfidenceLevel { + Green, + Yellow, + Red, +} + +impl ConfidenceLevel { + pub fn from_score(score: f64, green_threshold: f64, yellow_threshold: f64) -> Self { + if score >= green_threshold { + Self::Green + } else if score >= yellow_threshold { + Self::Yellow + } else { + Self::Red + } + } } -/// Chain event for audit trail +impl std::fmt::Display for ConfidenceLevel { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ConfidenceLevel::Green => write!(f, "green"), + ConfidenceLevel::Yellow => write!(f, "yellow"), + ConfidenceLevel::Red => write!(f, "red"), + } + } +} + +/// Directive evaluation - composite programmatic + LLM evaluation result #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainEvent { +pub struct DirectiveEvaluation { pub id: Uuid, - pub chain_id: Uuid, - pub event_type: String, + pub directive_id: Uuid, + pub chain_id: Option<Uuid>, + pub step_id: Option<Uuid>, pub contract_id: Option<Uuid>, + pub evaluation_type: String, + pub evaluation_number: i32, + pub evaluator: Option<String>, + pub passed: bool, + pub overall_score: Option<f64>, + pub confidence_level: Option<String>, #[sqlx(json)] - pub event_data: Option<serde_json::Value>, + #[serde(default)] + pub programmatic_results: serde_json::Value, + #[sqlx(json)] + #[serde(default)] + pub llm_results: serde_json::Value, + #[sqlx(json)] + #[serde(default)] + pub criteria_results: serde_json::Value, + pub summary_feedback: String, + pub rework_instructions: Option<String>, + #[sqlx(json)] + pub directive_snapshot: Option<serde_json::Value>, + #[sqlx(json)] + pub deliverables_snapshot: Option<serde_json::Value>, + pub started_at: DateTime<Utc>, + pub completed_at: Option<DateTime<Utc>>, pub created_at: DateTime<Utc>, } -/// Summary of a chain for list views -#[derive(Debug, Clone, FromRow, Serialize, ToSchema)] +/// Directive event - audit stream entry +#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainSummary { +pub struct DirectiveEvent { pub id: Uuid, - pub name: String, - pub description: Option<String>, - pub status: String, - pub loop_enabled: bool, - pub loop_current_iteration: Option<i32>, - pub contract_count: i64, - pub completed_count: i64, - pub version: i32, + pub directive_id: Uuid, + pub chain_id: Option<Uuid>, + pub step_id: Option<Uuid>, + pub event_type: String, + pub severity: String, + #[sqlx(json)] + pub event_data: Option<serde_json::Value>, + pub actor_type: String, + pub actor_id: Option<Uuid>, pub created_at: DateTime<Utc>, } -/// Chain with contracts for detail view -#[derive(Debug, Serialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainWithContracts { - #[serde(flatten)] - pub chain: Chain, - pub contracts: Vec<ChainContractDetail>, - pub repositories: Vec<ChainRepository>, -} - -/// Contract detail within a chain (includes contract info + chain link info) -#[derive(Debug, Clone, FromRow, Serialize, ToSchema)] +/// Directive verifier - pluggable verification configuration +#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainContractDetail { - pub chain_contract_id: Uuid, - pub contract_id: Uuid, - pub contract_name: String, - pub contract_status: String, - pub contract_phase: String, - #[sqlx(default)] - pub depends_on: Vec<Uuid>, - pub order_index: i32, - pub editor_x: Option<f64>, - pub editor_y: Option<f64>, - /// Evaluation status: pending, passed, failed, rework - #[sqlx(default)] - pub evaluation_status: Option<String>, - /// Number of evaluation retries - #[sqlx(default)] - pub evaluation_retry_count: i32, - /// Maximum evaluation retry attempts +pub struct DirectiveVerifier { + pub id: Uuid, + pub directive_id: Uuid, + pub name: String, + pub verifier_type: String, + pub command: Option<String>, + pub working_directory: Option<String>, + pub timeout_seconds: Option<i32>, + #[sqlx(json)] + #[serde(default)] + pub environment: serde_json::Value, + pub auto_detect: bool, #[sqlx(default)] - pub max_evaluation_retries: i32, - /// When the chain contract was created + pub detect_files: Vec<String>, + pub weight: f64, + pub required: bool, + pub enabled: bool, + pub last_run_at: Option<DateTime<Utc>>, + #[sqlx(json)] + pub last_result: Option<serde_json::Value>, pub created_at: DateTime<Utc>, + pub updated_at: DateTime<Utc>, } -/// DAG graph structure for visualization -#[derive(Debug, Serialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainGraphResponse { - pub chain_id: Uuid, - pub chain_name: String, - pub chain_status: String, - pub nodes: Vec<ChainGraphNode>, - pub edges: Vec<ChainGraphEdge>, -} - -/// Node in chain DAG graph -#[derive(Debug, Serialize, ToSchema)] +/// Directive approval - human-in-the-loop gate +#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainGraphNode { +pub struct DirectiveApproval { pub id: Uuid, - pub contract_id: Uuid, - pub name: String, + pub directive_id: Uuid, + pub step_id: Option<Uuid>, + pub approval_type: String, + pub description: String, + #[sqlx(json)] + pub context: Option<serde_json::Value>, + pub urgency: String, pub status: String, - pub phase: String, - pub x: f64, - pub y: f64, + pub response: Option<String>, + pub responded_by: Option<Uuid>, + pub responded_at: Option<DateTime<Utc>>, + pub expires_at: Option<DateTime<Utc>>, + pub created_at: DateTime<Utc>, } -/// Edge in chain DAG graph -#[derive(Debug, Clone, Serialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainGraphEdge { - pub from: Uuid, - pub to: Uuid, -} +// ============================================================================= +// Directive Request/Response Types +// ============================================================================= -/// Response for chain list endpoint -#[derive(Debug, Serialize, ToSchema)] +/// Request to create a directive from a goal +#[derive(Debug, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainListResponse { - pub chains: Vec<ChainSummary>, - pub total: i64, +pub struct CreateDirectiveRequest { + pub goal: String, + pub title: Option<String>, + pub repository_url: Option<String>, + pub local_path: Option<String>, + pub base_branch: Option<String>, + pub autonomy_level: Option<String>, + pub requirements: Option<serde_json::Value>, + pub acceptance_criteria: Option<serde_json::Value>, + pub confidence_threshold_green: Option<f64>, + pub confidence_threshold_yellow: Option<f64>, + pub max_total_cost_usd: Option<f64>, + pub max_wall_time_minutes: Option<i32>, } -/// Request payload for creating a new chain -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +/// Request to update a directive +#[derive(Debug, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct CreateChainRequest { - /// Name of the chain - pub name: String, - /// Optional description - pub description: Option<String>, - /// Repositories for this chain - pub repositories: Option<Vec<AddChainRepositoryRequest>>, - /// Enable loop mode for iterative execution - #[serde(default)] - pub loop_enabled: Option<bool>, - /// Maximum loop iterations (default: 10) - pub loop_max_iterations: Option<i32>, - /// Progress check prompt for evaluating loop completion - pub loop_progress_check: Option<String>, - /// Contracts to create within this chain - pub contracts: Option<Vec<CreateChainContractRequest>>, +pub struct UpdateDirectiveRequest { + pub title: Option<String>, + pub goal: Option<String>, + pub requirements: Option<serde_json::Value>, + pub acceptance_criteria: Option<serde_json::Value>, + pub constraints: Option<serde_json::Value>, + pub external_dependencies: Option<serde_json::Value>, + pub autonomy_level: Option<String>, + pub confidence_threshold_green: Option<f64>, + pub confidence_threshold_yellow: Option<f64>, + pub max_total_cost_usd: Option<f64>, + pub max_wall_time_minutes: Option<i32>, + pub max_rework_cycles: Option<i32>, + pub max_chain_regenerations: Option<i32>, + pub version: i32, } -/// Request to add a repository to a chain -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +/// Directive summary for list views +#[derive(Debug, Clone, Serialize, FromRow, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct AddChainRepositoryRequest { - /// Display name for the repository - pub name: String, - /// Remote repository URL (for remote repos) - pub repository_url: Option<String>, - /// Local filesystem path (for local repos) - pub local_path: Option<String>, - /// Source type: remote, local, or managed - #[serde(default = "default_source_type")] - pub source_type: String, - /// Whether this is the primary repository - #[serde(default)] - pub is_primary: bool, +pub struct DirectiveSummary { + pub id: Uuid, + pub title: String, + pub goal: String, + pub status: String, + pub autonomy_level: String, + pub current_confidence: Option<f64>, + pub completed_steps: i32, + pub total_steps: i32, + pub chain_generation_count: i32, + pub started_at: Option<DateTime<Utc>>, + pub created_at: DateTime<Utc>, } -fn default_source_type() -> String { - "remote".to_string() +/// Directive with progress, chain, events, and approvals +#[derive(Debug, Serialize, ToSchema)] +#[serde(rename_all = "camelCase")] +pub struct DirectiveWithProgress { + #[serde(flatten)] + pub directive: Directive, + pub chain: Option<DirectiveChain>, + pub steps: Vec<ChainStep>, + pub recent_events: Vec<DirectiveEvent>, + pub pending_approvals: Vec<DirectiveApproval>, } -/// Request to create a contract within a chain -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] +/// Request to add a step to a chain +#[derive(Debug, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct CreateChainContractRequest { - /// Name of the contract +pub struct AddStepRequest { pub name: String, - /// Optional description pub description: Option<String>, - /// Contract type - #[serde(default)] + pub step_type: Option<String>, pub contract_type: Option<String>, - /// Initial phase pub initial_phase: Option<String>, - /// Phases for the contract + pub task_plan: Option<String>, pub phases: Option<Vec<String>>, - /// Names of contracts this depends on (resolved to IDs) - pub depends_on: Option<Vec<String>>, - /// Tasks to create in this contract - pub tasks: Option<Vec<CreateChainTaskRequest>>, - /// Deliverables for this contract - pub deliverables: Option<Vec<CreateChainDeliverableRequest>>, - /// Position in GUI editor + pub depends_on: Option<Vec<Uuid>>, + pub parallel_group: Option<String>, + pub requirement_ids: Option<Vec<String>>, + pub acceptance_criteria_ids: Option<Vec<String>>, + pub verifier_config: Option<serde_json::Value>, pub editor_x: Option<f64>, pub editor_y: Option<f64>, } -/// Task definition within a chain contract -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct CreateChainTaskRequest { - pub name: String, - pub plan: String, -} - -/// Deliverable definition within a chain contract -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct CreateChainDeliverableRequest { - pub id: String, - pub name: String, - pub priority: Option<String>, -} - -/// Validation configuration for checkpoint contracts. -/// Checkpoint contracts validate the outputs of their upstream dependencies -/// before allowing downstream contracts to proceed. -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct CheckpointValidation { - /// Check that all required deliverables from upstream contracts exist - #[serde(default)] - pub check_deliverables: bool, - - /// Run tests in the repository (requires repository to be configured) - #[serde(default)] - pub run_tests: bool, - - /// Custom validation instructions for Claude to execute. - /// Claude will review the outputs of upstream contracts and verify they meet these criteria. - pub check_content: Option<String>, - - /// Action to take on validation failure: "block" (default), "retry", "warn" - /// - block: Fail the checkpoint and block downstream contracts - /// - retry: Mark upstream contracts for retry (up to max_retries) - /// - warn: Log warning but allow downstream to proceed - #[serde(default = "default_checkpoint_on_failure")] - pub on_failure: String, - - /// Maximum retry attempts for upstream contracts (when on_failure = "retry") - #[serde(default = "default_checkpoint_max_retries")] - pub max_retries: i32, -} - -fn default_checkpoint_on_failure() -> String { - "block".to_string() -} - -fn default_checkpoint_max_retries() -> i32 { - 3 -} - -impl Default for CheckpointValidation { - fn default() -> Self { - Self { - check_deliverables: false, - run_tests: false, - check_content: None, - on_failure: default_checkpoint_on_failure(), - max_retries: default_checkpoint_max_retries(), - } - } -} - -/// Request to update an existing chain -#[derive(Debug, Clone, Deserialize, ToSchema)] +/// Request to update a step +#[derive(Debug, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct UpdateChainRequest { +pub struct UpdateStepRequest { pub name: Option<String>, pub description: Option<String>, - pub status: Option<String>, - pub loop_enabled: Option<bool>, - pub loop_max_iterations: Option<i32>, - pub loop_progress_check: Option<String>, - /// Version for optimistic locking - pub version: Option<i32>, -} - -/// Request to add a contract to a chain -#[derive(Debug, Clone, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct AddContractToChainRequest { - /// Existing contract ID to add - pub contract_id: Option<Uuid>, - /// Or create a new contract with this definition - pub new_contract: Option<CreateChainContractRequest>, - /// Contract IDs this depends on + pub task_plan: Option<String>, pub depends_on: Option<Vec<Uuid>>, - /// Position in GUI editor + pub requirement_ids: Option<Vec<String>>, + pub acceptance_criteria_ids: Option<Vec<String>>, + pub verifier_config: Option<serde_json::Value>, pub editor_x: Option<f64>, pub editor_y: Option<f64>, } -/// Editor data model for GUI chain editor -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainEditorData { - pub id: Option<Uuid>, - pub name: String, - pub description: Option<String>, - pub repositories: Vec<ChainRepository>, - pub loop_enabled: bool, - pub loop_max_iterations: Option<i32>, - pub loop_progress_check: Option<String>, - pub nodes: Vec<ChainEditorNode>, - pub edges: Vec<ChainEditorEdge>, -} - -/// Node in chain editor -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainEditorNode { - pub id: String, - pub x: f64, - pub y: f64, - pub contract: ChainEditorContract, -} - -/// Contract data in chain editor node -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainEditorContract { - pub name: String, - pub description: Option<String>, - #[serde(rename = "type")] - pub contract_type: String, - pub phases: Vec<String>, - pub tasks: Vec<ChainEditorTask>, - pub deliverables: Vec<ChainEditorDeliverable>, -} - -/// Task in chain editor -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainEditorTask { - pub name: String, - pub plan: String, -} - -/// Deliverable in chain editor -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainEditorDeliverable { - pub id: String, - pub name: String, - pub priority: String, -} - -/// Edge in chain editor -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ChainEditorEdge { - pub from: String, - pub to: String, -} - -// ============================================================================= -// Chain Contract Definitions (stored specs for on-demand contract creation) -// ============================================================================= - -/// Contract definition within a chain - stored spec before actual contract is created -#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] +/// Chain graph response for DAG visualization +#[derive(Debug, Serialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainContractDefinition { - pub id: Uuid, +pub struct DirectiveChainGraphResponse { pub chain_id: Uuid, - pub name: String, - pub description: Option<String>, - pub contract_type: String, - pub initial_phase: Option<String>, - /// Names of other definitions this depends on - #[sqlx(default)] - pub depends_on_names: Vec<String>, - /// Task definitions as JSON: [{name, plan}, ...] - pub tasks: Option<serde_json::Value>, - /// Deliverable definitions as JSON: [{id, name, priority}, ...] - pub deliverables: Option<serde_json::Value>, - /// Validation configuration for checkpoint contracts (JSON) - pub validation: Option<serde_json::Value>, - /// Requirement IDs this contract addresses (for traceability) - #[sqlx(default)] - #[serde(default)] - pub requirement_ids: Vec<String>, - /// Acceptance criteria for this contract (JSON array) - #[serde(default)] - pub acceptance_criteria: Option<serde_json::Value>, - /// Whether LLM evaluation is enabled for this contract - #[serde(default = "default_evaluation_enabled")] - #[sqlx(default)] - pub evaluation_enabled: bool, - /// Pass threshold for evaluation (0.0-1.0) - pub pass_threshold: Option<f64>, - /// Position in GUI editor - pub editor_x: Option<f64>, - pub editor_y: Option<f64>, - pub order_index: i32, - pub created_at: DateTime<Utc>, + pub directive_id: Uuid, + pub nodes: Vec<DirectiveChainGraphNode>, + pub edges: Vec<DirectiveChainGraphEdge>, } -/// Request to add a contract definition to a chain -#[derive(Debug, Clone, Deserialize, ToSchema)] +/// Node in directive chain graph +#[derive(Debug, Serialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct AddContractDefinitionRequest { +pub struct DirectiveChainGraphNode { + pub id: Uuid, pub name: String, - pub description: Option<String>, - #[serde(default = "default_contract_type")] - pub contract_type: String, - pub initial_phase: Option<String>, - /// Names of other definitions this depends on - pub depends_on: Option<Vec<String>>, - /// Task definitions - pub tasks: Option<Vec<CreateChainTaskRequest>>, - /// Deliverable definitions - pub deliverables: Option<Vec<CreateChainDeliverableRequest>>, - /// Validation configuration (for checkpoint contracts) - pub validation: Option<CheckpointValidation>, - /// Position in GUI editor - pub editor_x: Option<f64>, - pub editor_y: Option<f64>, -} - -fn default_contract_type() -> String { - "simple".to_string() -} - -/// Request to update a contract definition -#[derive(Debug, Clone, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct UpdateContractDefinitionRequest { - pub name: Option<String>, - pub description: Option<String>, - pub contract_type: Option<String>, - pub initial_phase: Option<String>, - pub depends_on: Option<Vec<String>>, - pub tasks: Option<Vec<CreateChainTaskRequest>>, - pub deliverables: Option<Vec<CreateChainDeliverableRequest>>, - /// Validation configuration (for checkpoint contracts) - pub validation: Option<CheckpointValidation>, + pub step_type: String, + pub status: String, + pub confidence_score: Option<f64>, + pub confidence_level: Option<String>, + pub contract_id: Option<Uuid>, pub editor_x: Option<f64>, pub editor_y: Option<f64>, } -/// Request to start a chain (kept for backwards compatibility) -#[derive(Debug, Clone, Deserialize, ToSchema)] +/// Edge in directive chain graph +#[derive(Debug, Serialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct StartChainRequest { - /// Repository URL (reserved for future use) - pub repository_url: Option<String>, +pub struct DirectiveChainGraphEdge { + pub source: Uuid, + pub target: Uuid, } -/// Response when starting a chain -#[derive(Debug, Clone, Serialize, ToSchema)] +/// Start directive response +#[derive(Debug, Serialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct StartChainResponse { +pub struct StartDirectiveResponse { + pub directive_id: Uuid, pub chain_id: Uuid, - /// Root contracts created (those with no dependencies) - pub contracts_created: Vec<Uuid>, + pub chain_generation: i32, + pub steps: Vec<ChainStep>, pub status: String, } -/// Graph node for definitions (before contracts are created) -#[derive(Debug, Clone, Serialize, ToSchema)] +/// Request to create a verifier +#[derive(Debug, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainDefinitionGraphNode { - pub id: Uuid, +pub struct CreateVerifierRequest { pub name: String, - pub contract_type: String, - pub x: f64, - pub y: f64, - /// Whether this definition has been instantiated as a contract - pub is_instantiated: bool, - /// The contract ID if instantiated - pub contract_id: Option<Uuid>, - pub contract_status: Option<String>, + pub verifier_type: String, + pub command: Option<String>, + pub working_directory: Option<String>, + pub timeout_seconds: Option<i32>, + pub environment: Option<serde_json::Value>, + pub weight: Option<f64>, + pub required: Option<bool>, } -/// Graph response for definitions -#[derive(Debug, Clone, Serialize, ToSchema)] +/// Request to update a verifier +#[derive(Debug, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainDefinitionGraphResponse { - pub chain_id: Uuid, - pub chain_name: String, - pub chain_status: String, - pub nodes: Vec<ChainDefinitionGraphNode>, - pub edges: Vec<ChainGraphEdge>, +pub struct UpdateVerifierRequest { + pub name: Option<String>, + pub command: Option<String>, + pub working_directory: Option<String>, + pub timeout_seconds: Option<i32>, + pub weight: Option<f64>, + pub required: Option<bool>, + pub enabled: Option<bool>, } -// ============================================================================= -// Chain Directives (formal specification documents for directive-driven chains) -// ============================================================================= - -/// Chain directive - formal specification document that drives chain creation and evaluation -#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] +/// Approval action request +#[derive(Debug, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] -pub struct ChainDirective { - pub id: Uuid, - pub chain_id: Uuid, - pub version: i32, - /// Requirements as JSON: [{ id, title, description, priority, category, parentId? }] - #[sqlx(json)] - pub requirements: serde_json::Value, - /// Acceptance criteria as JSON: [{ id, requirementIds[], description, testable, verificationMethod }] - #[sqlx(json)] - pub acceptance_criteria: serde_json::Value, - /// Constraints as JSON: [{ id, type, description, impact }] - #[sqlx(json)] - pub constraints: serde_json::Value, - /// External dependencies as JSON: [{ id, name, type, status, requiredBy[] }] - #[sqlx(json)] - pub external_dependencies: serde_json::Value, - /// Source type: 'manual', 'llm_generated', 'imported' - pub source_type: String, - pub created_at: DateTime<Utc>, - pub updated_at: DateTime<Utc>, +pub struct ApprovalActionRequest { + pub response: Option<String>, } -/// Requirement in a directive +/// Directive requirement (shared type used in directive specification) #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] pub struct DirectiveRequirement { pub id: String, pub title: String, pub description: String, - /// Priority: 'must', 'should', 'could', 'wont' pub priority: String, - /// Category: 'feature', 'infrastructure', 'testing', etc. pub category: Option<String>, - /// Parent requirement ID for hierarchical requirements + #[serde(skip_serializing_if = "Option::is_none")] pub parent_id: Option<String>, } -/// Acceptance criterion in a directive +/// Directive acceptance criterion #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "camelCase")] pub struct DirectiveAcceptanceCriterion { pub id: String, - /// Requirement IDs this criterion validates + #[serde(default)] pub requirement_ids: Vec<String>, pub description: String, + #[serde(default = "default_true")] pub testable: bool, - /// Verification method: 'automated', 'manual', 'review', 'llm' - pub verification_method: String, + pub verification_method: Option<String>, } -/// Constraint in a directive -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct DirectiveConstraint { - pub id: String, - /// Type: 'technical', 'business', 'time', 'resource' - #[serde(rename = "type")] - pub constraint_type: String, - pub description: String, - /// Impact: 'high', 'medium', 'low' - pub impact: String, +fn default_true() -> bool { + true } -/// External dependency in a directive -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct DirectiveExternalDependency { - pub id: String, - pub name: String, - /// Type: 'api', 'service', 'library', 'data' - #[serde(rename = "type")] - pub dependency_type: String, - /// Status: 'available', 'pending', 'blocked' - pub status: String, - /// Requirement IDs that need this dependency - pub required_by: Vec<String>, -} +// Old chain types (Chain, ChainContract, ChainContractDefinition, ChainDirective, +// ContractEvaluation, ChainEvent, ChainRepository, etc.) have been replaced by +// the directive system above: Directive, DirectiveChain, ChainStep, +// DirectiveEvaluation, DirectiveEvent, DirectiveVerifier, DirectiveApproval. -/// Request to create or update a chain directive -#[derive(Debug, Clone, Deserialize, ToSchema)] +// Legacy types kept temporarily for chain runner/parser compatibility during migration. +// These will be removed once the chain daemon module is replaced. + +/// Request payload for creating a new chain (legacy - used by chain runner) +#[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct CreateChainDirectiveRequest { - pub requirements: Option<Vec<DirectiveRequirement>>, - pub acceptance_criteria: Option<Vec<DirectiveAcceptanceCriterion>>, - pub constraints: Option<Vec<DirectiveConstraint>>, - pub external_dependencies: Option<Vec<DirectiveExternalDependency>>, - pub source_type: Option<String>, +pub struct CreateChainRequest { + pub name: String, + pub description: Option<String>, + pub repository_url: Option<String>, + pub repositories: Option<Vec<AddChainRepositoryRequest>>, + pub loop_enabled: Option<bool>, + pub loop_max_iterations: Option<i32>, + pub loop_progress_check: Option<String>, + pub contracts: Option<Vec<CreateChainContractRequest>>, } -/// Request to initialize a directive-driven chain -#[derive(Debug, Clone, Deserialize, ToSchema)] +/// Request to add a repository to a chain (legacy - used by chain runner) +#[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct InitChainRequest { - /// High-level goal/description for the directive contract - pub goal: String, - /// Repository URL for chain contracts +pub struct AddChainRepositoryRequest { + pub name: String, pub repository_url: Option<String>, - /// Local path for chain contracts pub local_path: Option<String>, - /// Whether to enable phase guard (user approval between phases) + #[serde(default = "default_source_type")] + pub source_type: String, #[serde(default)] - pub phase_guard: bool, -} - -/// Response from initializing a directive-driven chain -#[derive(Debug, Clone, Serialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct InitChainResponse { - pub chain_id: Uuid, - pub directive_contract_id: Uuid, - pub supervisor_task_id: Option<Uuid>, -} - -// ============================================================================= -// Contract Evaluations (LLM evaluation results for completed contracts) -// ============================================================================= - -/// Evaluation status for chain contracts -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "snake_case")] -pub enum EvaluationStatus { - /// Not yet evaluated - Pending, - /// Currently being evaluated - Evaluating, - /// Evaluation passed - Passed, - /// Evaluation failed - Failed, - /// Contract is being reworked after failed evaluation - Rework, - /// Max retries exceeded, escalated to user - Escalated, - /// User approved despite partial failure - ApprovedWithIssues, -} - -impl std::fmt::Display for EvaluationStatus { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::Pending => write!(f, "pending"), - Self::Evaluating => write!(f, "evaluating"), - Self::Passed => write!(f, "passed"), - Self::Failed => write!(f, "failed"), - Self::Rework => write!(f, "rework"), - Self::Escalated => write!(f, "escalated"), - Self::ApprovedWithIssues => write!(f, "approved_with_issues"), - } - } -} - -impl std::str::FromStr for EvaluationStatus { - type Err = String; - - fn from_str(s: &str) -> Result<Self, Self::Err> { - match s.to_lowercase().as_str() { - "pending" => Ok(Self::Pending), - "evaluating" => Ok(Self::Evaluating), - "passed" => Ok(Self::Passed), - "failed" => Ok(Self::Failed), - "rework" => Ok(Self::Rework), - "escalated" => Ok(Self::Escalated), - "approved_with_issues" => Ok(Self::ApprovedWithIssues), - _ => Err(format!("Unknown evaluation status: {}", s)), - } - } -} - -/// Contract evaluation - LLM evaluation result after contract completion -#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ContractEvaluation { - pub id: Uuid, - pub contract_id: Uuid, - pub chain_id: Option<Uuid>, - pub chain_contract_id: Option<Uuid>, - /// Evaluation attempt number (1-based) - pub evaluation_number: i32, - /// Model used for evaluation - pub evaluator_model: Option<String>, - /// Whether the evaluation passed - pub passed: bool, - /// Overall score (0.0-1.0) - pub overall_score: Option<f64>, - /// Per-criterion results as JSON - #[sqlx(json)] - pub criteria_results: serde_json::Value, - /// Summary feedback from the evaluator - pub summary_feedback: String, - /// Instructions for rework if evaluation failed - pub rework_instructions: Option<String>, - /// Snapshot of directive at evaluation time - pub directive_snapshot: Option<serde_json::Value>, - /// Snapshot of deliverables at evaluation time - pub deliverables_snapshot: Option<serde_json::Value>, - pub started_at: DateTime<Utc>, - pub completed_at: Option<DateTime<Utc>>, - pub created_at: DateTime<Utc>, -} - -/// Per-criterion evaluation result -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct EvaluationCriterionResult { - pub criterion_id: String, - pub criterion_text: String, - pub passed: bool, - /// Score (0.0-1.0) - pub score: f64, - pub feedback: String, - /// Evidence supporting the evaluation - pub evidence: Vec<String>, -} - -/// Request to create a contract evaluation -#[derive(Debug, Clone, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct CreateContractEvaluationRequest { - pub contract_id: Uuid, - pub chain_id: Option<Uuid>, - pub chain_contract_id: Option<Uuid>, - pub evaluator_model: Option<String>, - pub passed: bool, - pub overall_score: Option<f64>, - pub criteria_results: Vec<EvaluationCriterionResult>, - pub summary_feedback: String, - pub rework_instructions: Option<String>, + pub is_primary: bool, } -/// Summary of contract evaluation for list views -#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)] -#[serde(rename_all = "camelCase")] -pub struct ContractEvaluationSummary { - pub id: Uuid, - pub contract_id: Uuid, - pub evaluation_number: i32, - pub passed: bool, - pub overall_score: Option<f64>, - pub summary_feedback: String, - pub created_at: DateTime<Utc>, +fn default_source_type() -> String { + "remote".to_string() } -/// Response listing evaluations for a chain or contract -#[derive(Debug, Clone, Serialize, ToSchema)] +/// Request to create a contract within a chain (legacy - used by chain runner) +#[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct ContractEvaluationsResponse { - pub evaluations: Vec<ContractEvaluationSummary>, - pub total: i64, +pub struct CreateChainContractRequest { + pub name: String, + pub description: Option<String>, + #[serde(default)] + pub contract_type: Option<String>, + pub initial_phase: Option<String>, + pub phases: Option<Vec<String>>, + pub depends_on: Option<Vec<String>>, + pub tasks: Option<Vec<CreateChainTaskRequest>>, + pub deliverables: Option<Vec<CreateChainDeliverableRequest>>, + pub editor_x: Option<f64>, + pub editor_y: Option<f64>, } -/// Traceability matrix entry - maps requirements to contracts -#[derive(Debug, Clone, Serialize, ToSchema)] +/// Task definition within a chain contract (legacy - used by chain runner) +#[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct TraceabilityEntry { - pub requirement_id: String, - pub requirement_title: String, - pub contract_definition_ids: Vec<Uuid>, - pub contract_definition_names: Vec<String>, - pub acceptance_criteria_ids: Vec<String>, +pub struct CreateChainTaskRequest { + pub name: String, + pub plan: String, } -/// Response for directive traceability -#[derive(Debug, Clone, Serialize, ToSchema)] +/// Deliverable definition within a chain contract (legacy - used by chain runner) +#[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct DirectiveTraceabilityResponse { - pub chain_id: Uuid, - pub entries: Vec<TraceabilityEntry>, - /// Requirements not mapped to any contract - pub uncovered_requirements: Vec<String>, +pub struct CreateChainDeliverableRequest { + pub id: String, + pub name: String, + pub priority: Option<String>, } // ============================================================================= diff --git a/makima/src/db/repository.rs b/makima/src/db/repository.rs index 7be7bc8..eeda4a5 100644 --- a/makima/src/db/repository.rs +++ b/makima/src/db/repository.rs @@ -6,23 +6,22 @@ use sqlx::PgPool; use uuid::Uuid; use super::models::{ - AddChainRepositoryRequest, AddContractDefinitionRequest, AddContractToChainRequest, Chain, - ChainContract, ChainContractDefinition, ChainContractDetail, ChainDefinitionGraphNode, - ChainDefinitionGraphResponse, ChainDirective, ChainEditorContract, ChainEditorData, - ChainEditorDeliverable, ChainEditorEdge, ChainEditorNode, ChainEditorTask, ChainEvent, - ChainGraphEdge, ChainGraphNode, ChainGraphResponse, ChainRepository, ChainSummary, - ChainWithContracts, CheckpointPatch, CheckpointPatchInfo, Contract, ContractChatConversation, - ContractChatMessageRecord, ContractEvaluation, ContractEvaluationSummary, ContractEvent, - ContractRepository, ContractSummary, ContractTypeTemplateRecord, ConversationMessage, - ConversationSnapshot, CreateChainDirectiveRequest, CreateChainRequest, - CreateContractEvaluationRequest, CreateContractRequest, CreateFileRequest, CreateTaskRequest, - CreateTemplateRequest, Daemon, DaemonTaskAssignment, DaemonWithCapacity, DeliverableDefinition, - DirectiveTraceabilityResponse, EvaluationCriterionResult, File, FileSummary, FileVersion, - HistoryEvent, HistoryQueryFilters, InitChainRequest, InitChainResponse, MeshChatConversation, - MeshChatMessageRecord, PhaseChangeResult, PhaseConfig, PhaseDefinition, - SupervisorHeartbeatRecord, SupervisorState, Task, TaskCheckpoint, TaskEvent, TaskSummary, - TraceabilityEntry, UpdateChainRequest, UpdateContractDefinitionRequest, UpdateContractRequest, - UpdateFileRequest, UpdateTaskRequest, UpdateTemplateRequest, + // Core types + CheckpointPatch, CheckpointPatchInfo, Contract, ContractChatConversation, + ContractChatMessageRecord, ContractEvent, ContractRepository, ContractSummary, + ContractTypeTemplateRecord, ConversationMessage, ConversationSnapshot, + CreateContractRequest, CreateFileRequest, CreateTaskRequest, CreateTemplateRequest, + Daemon, DaemonTaskAssignment, DaemonWithCapacity, DeliverableDefinition, + File, FileSummary, FileVersion, HistoryEvent, HistoryQueryFilters, + MeshChatConversation, MeshChatMessageRecord, PhaseChangeResult, PhaseConfig, + PhaseDefinition, SupervisorHeartbeatRecord, SupervisorState, Task, TaskCheckpoint, + TaskEvent, TaskSummary, UpdateContractRequest, UpdateFileRequest, UpdateTaskRequest, + UpdateTemplateRequest, + // Directive types + AddStepRequest, ChainStep, CreateDirectiveRequest, Directive, DirectiveApproval, + DirectiveChain, DirectiveChainGraphEdge, DirectiveChainGraphNode, DirectiveChainGraphResponse, + DirectiveEvaluation, DirectiveEvent, DirectiveSummary, DirectiveVerifier, + DirectiveWithProgress, UpdateDirectiveRequest, UpdateStepRequest, }; /// Repository error types. @@ -4906,46 +4905,140 @@ pub async fn sync_supervisor_state( } // ============================================================================= -// Chain Operations (DAG of contracts for multi-contract orchestration) +// Directive Operations (top-level orchestration entity) // ============================================================================= +// TODO: Implement directive CRUD functions +// - create_directive_for_owner +// - get_directive_for_owner +// - list_directives_for_owner +// - update_directive_for_owner +// - archive_directive_for_owner +// - update_directive_status -/// Create a new chain for a specific owner. -pub async fn create_chain_for_owner( +// ============================================================================= +// Directive Chain Operations (generated execution plans) +// ============================================================================= +// TODO: Implement chain CRUD functions +// - create_directive_chain +// - get_current_chain +// - supersede_chain + +// ============================================================================= +// Chain Step Operations (nodes in the DAG) +// ============================================================================= +// TODO: Implement step CRUD functions +// - create_chain_step +// - update_chain_step +// - delete_chain_step +// - find_ready_steps +// - update_step_status +// - update_step_contract +// - update_step_confidence +// - increment_step_rework_count + +// ============================================================================= +// Directive Evaluation Operations +// ============================================================================= +// TODO: Implement evaluation functions +// - create_directive_evaluation +// - list_step_evaluations +// - list_directive_evaluations + +// ============================================================================= +// Directive Event Operations (audit stream) +// ============================================================================= +// TODO: Implement event functions +// - emit_directive_event +// - list_directive_events + +// ============================================================================= +// Directive Verifier Operations +// ============================================================================= +// TODO: Implement verifier CRUD functions +// - create_directive_verifier +// - list_directive_verifiers +// - update_directive_verifier + +// ============================================================================= +// Directive Approval Operations (human-in-the-loop) +// ============================================================================= +// TODO: Implement approval functions +// - create_approval_request +// - resolve_approval +// - list_pending_approvals + +// NOTE: Old chain functions removed. See git history for reference. +// Old functions included: create_chain_for_owner, get_chain_for_owner, +// list_chains_for_owner, update_chain_for_owner, delete_chain_for_owner, +// add_contract_to_chain, remove_contract_from_chain, list_chain_contracts, +// get_chain_with_contracts, list_chain_repositories, add_chain_repository, +// delete_chain_repository, set_chain_repository_primary, get_chain_graph, +// record_chain_event, list_chain_events, increment_chain_loop, complete_chain, +// get_ready_chain_contracts, is_chain_complete, get_chain_editor_data, +// create_chain_contract_definition, list_chain_contract_definitions, +// update_chain_contract_definition, delete_chain_contract_definition, +// get_chain_definition_graph, update_chain_status, progress_chain, +// create_chain_directive, get_chain_directive, update_chain_directive, +// delete_chain_directive, create_contract_evaluation, get_contract_evaluation, +// list_chain_evaluations, update_chain_contract_evaluation_status, +// mark_chain_contract_original_completion, get_chain_contract_by_contract_id, +// init_chain_for_owner. + +// ============================================================================= +// Directive Operations +// ============================================================================= + +/// Create a new directive for an owner. +pub async fn create_directive_for_owner( pool: &PgPool, owner_id: Uuid, - req: CreateChainRequest, -) -> Result<Chain, sqlx::Error> { - let loop_enabled = req.loop_enabled.unwrap_or(false); - let loop_max_iterations = req.loop_max_iterations.unwrap_or(10); - - sqlx::query_as::<_, Chain>( - r#" - INSERT INTO chains (owner_id, name, description, loop_enabled, loop_max_iterations, loop_progress_check) - VALUES ($1, $2, $3, $4, $5, $6) + req: CreateDirectiveRequest, +) -> Result<Directive, sqlx::Error> { + let title = req.title.unwrap_or_else(|| truncate_string(&req.goal, 100)); + let autonomy_level = req.autonomy_level.unwrap_or_else(|| "guardrails".to_string()); + let green_threshold = req.confidence_threshold_green.unwrap_or(0.85); + let yellow_threshold = req.confidence_threshold_yellow.unwrap_or(0.60); + let requirements = req.requirements.unwrap_or(serde_json::json!([])); + let acceptance_criteria = req.acceptance_criteria.unwrap_or(serde_json::json!([])); + + sqlx::query_as::<_, Directive>( + r#" + INSERT INTO directives ( + owner_id, title, goal, requirements, acceptance_criteria, + autonomy_level, confidence_threshold_green, confidence_threshold_yellow, + repository_url, local_path, base_branch, + max_total_cost_usd, max_wall_time_minutes + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) RETURNING * "#, ) .bind(owner_id) - .bind(&req.name) - .bind(&req.description) - .bind(loop_enabled) - .bind(loop_max_iterations) - .bind(&req.loop_progress_check) + .bind(&title) + .bind(&req.goal) + .bind(&requirements) + .bind(&acceptance_criteria) + .bind(&autonomy_level) + .bind(green_threshold) + .bind(yellow_threshold) + .bind(&req.repository_url) + .bind(&req.local_path) + .bind(&req.base_branch) + .bind(req.max_total_cost_usd) + .bind(req.max_wall_time_minutes) .fetch_one(pool) .await } -/// Get a chain by ID, scoped to owner. -pub async fn get_chain_for_owner( +/// Get a directive by ID, scoped to owner. +pub async fn get_directive_for_owner( pool: &PgPool, id: Uuid, owner_id: Uuid, -) -> Result<Option<Chain>, sqlx::Error> { - sqlx::query_as::<_, Chain>( +) -> Result<Option<Directive>, sqlx::Error> { + sqlx::query_as::<_, Directive>( r#" - SELECT * - FROM chains - WHERE id = $1 AND owner_id = $2 + SELECT * FROM directives WHERE id = $1 AND owner_id = $2 "#, ) .bind(id) @@ -4954,817 +5047,485 @@ pub async fn get_chain_for_owner( .await } -/// Get a chain by ID (no owner check - for internal use). -pub async fn get_chain(pool: &PgPool, id: Uuid) -> Result<Option<Chain>, sqlx::Error> { - sqlx::query_as::<_, Chain>( - r#" - SELECT * - FROM chains - WHERE id = $1 - "#, +/// Get a directive by ID (no owner check - for internal use). +pub async fn get_directive(pool: &PgPool, id: Uuid) -> Result<Option<Directive>, sqlx::Error> { + sqlx::query_as::<_, Directive>( + r#"SELECT * FROM directives WHERE id = $1"#, ) .bind(id) .fetch_optional(pool) .await } -/// List chains for a specific owner. -pub async fn list_chains_for_owner( +/// List directives for an owner. +pub async fn list_directives_for_owner( pool: &PgPool, owner_id: Uuid, -) -> Result<Vec<ChainSummary>, sqlx::Error> { - sqlx::query_as::<_, ChainSummary>( - r#" - SELECT - c.id, - c.name, - c.description, - c.status, - c.loop_enabled, - c.loop_current_iteration, - COUNT(DISTINCT cc.contract_id) as contract_count, - COUNT(DISTINCT CASE WHEN con.status = 'completed' THEN cc.contract_id END) as completed_count, - c.version, - c.created_at - FROM chains c - LEFT JOIN chain_contracts cc ON cc.chain_id = c.id - LEFT JOIN contracts con ON con.id = cc.contract_id - WHERE c.owner_id = $1 - GROUP BY c.id - ORDER BY c.created_at DESC - "#, - ) - .bind(owner_id) - .fetch_all(pool) - .await + status_filter: Option<&str>, +) -> Result<Vec<DirectiveSummary>, sqlx::Error> { + let query = if let Some(status) = status_filter { + sqlx::query_as::<_, DirectiveSummary>( + r#" + SELECT + d.id, d.title, d.goal, d.status, d.autonomy_level, + dc.current_confidence, + COALESCE(dc.completed_steps, 0) as completed_steps, + COALESCE(dc.total_steps, 0) as total_steps, + d.chain_generation_count, d.started_at, d.created_at + FROM directives d + LEFT JOIN directive_chains dc ON dc.id = d.current_chain_id + WHERE d.owner_id = $1 AND d.status = $2 + ORDER BY d.created_at DESC + "#, + ) + .bind(owner_id) + .bind(status) + } else { + sqlx::query_as::<_, DirectiveSummary>( + r#" + SELECT + d.id, d.title, d.goal, d.status, d.autonomy_level, + dc.current_confidence, + COALESCE(dc.completed_steps, 0) as completed_steps, + COALESCE(dc.total_steps, 0) as total_steps, + d.chain_generation_count, d.started_at, d.created_at + FROM directives d + LEFT JOIN directive_chains dc ON dc.id = d.current_chain_id + WHERE d.owner_id = $1 + ORDER BY d.created_at DESC + "#, + ) + .bind(owner_id) + }; + query.fetch_all(pool).await } -/// Update a chain. -pub async fn update_chain_for_owner( +/// Update a directive with optimistic locking. +pub async fn update_directive_for_owner( pool: &PgPool, id: Uuid, owner_id: Uuid, - req: UpdateChainRequest, -) -> Result<Chain, RepositoryError> { - // First get current version if optimistic locking requested - if let Some(expected_version) = req.version { - let current: Option<(i32,)> = sqlx::query_as( - "SELECT version FROM chains WHERE id = $1 AND owner_id = $2", - ) - .bind(id) - .bind(owner_id) - .fetch_optional(pool) - .await?; + req: UpdateDirectiveRequest, +) -> Result<Directive, RepositoryError> { + // First get current version + let current = sqlx::query_scalar::<_, i32>( + "SELECT version FROM directives WHERE id = $1 AND owner_id = $2" + ) + .bind(id) + .bind(owner_id) + .fetch_optional(pool) + .await? + .ok_or_else(|| RepositoryError::Database(sqlx::Error::RowNotFound))?; - if let Some((actual_version,)) = current { - if actual_version != expected_version { - return Err(RepositoryError::VersionConflict { - expected: expected_version, - actual: actual_version, - }); - } - } + if current != req.version { + return Err(RepositoryError::VersionConflict { + expected: req.version, + actual: current, + }); } - let result = sqlx::query_as::<_, Chain>( - r#" - UPDATE chains - SET - name = COALESCE($3, name), - description = COALESCE($4, description), - status = COALESCE($5, status), - loop_enabled = COALESCE($6, loop_enabled), - loop_max_iterations = COALESCE($7, loop_max_iterations), - loop_progress_check = COALESCE($8, loop_progress_check), + let directive = sqlx::query_as::<_, Directive>( + r#" + UPDATE directives SET + title = COALESCE($3, title), + goal = COALESCE($4, goal), + requirements = COALESCE($5, requirements), + acceptance_criteria = COALESCE($6, acceptance_criteria), + constraints = COALESCE($7, constraints), + external_dependencies = COALESCE($8, external_dependencies), + autonomy_level = COALESCE($9, autonomy_level), + confidence_threshold_green = COALESCE($10, confidence_threshold_green), + confidence_threshold_yellow = COALESCE($11, confidence_threshold_yellow), + max_total_cost_usd = COALESCE($12, max_total_cost_usd), + max_wall_time_minutes = COALESCE($13, max_wall_time_minutes), + max_rework_cycles = COALESCE($14, max_rework_cycles), + max_chain_regenerations = COALESCE($15, max_chain_regenerations), version = version + 1, updated_at = NOW() - WHERE id = $1 AND owner_id = $2 + WHERE id = $1 AND owner_id = $2 AND version = $16 RETURNING * "#, ) .bind(id) .bind(owner_id) - .bind(&req.name) - .bind(&req.description) - .bind(&req.status) - .bind(req.loop_enabled) - .bind(req.loop_max_iterations) - .bind(&req.loop_progress_check) + .bind(&req.title) + .bind(&req.goal) + .bind(&req.requirements) + .bind(&req.acceptance_criteria) + .bind(&req.constraints) + .bind(&req.external_dependencies) + .bind(&req.autonomy_level) + .bind(req.confidence_threshold_green) + .bind(req.confidence_threshold_yellow) + .bind(req.max_total_cost_usd) + .bind(req.max_wall_time_minutes) + .bind(req.max_rework_cycles) + .bind(req.max_chain_regenerations) + .bind(req.version) .fetch_one(pool) .await?; - Ok(result) + Ok(directive) } -/// Delete (archive) a chain. -pub async fn delete_chain_for_owner( +/// Update directive status. +pub async fn update_directive_status( pool: &PgPool, id: Uuid, - owner_id: Uuid, -) -> Result<bool, sqlx::Error> { - let result = sqlx::query( - r#" - UPDATE chains - SET status = 'archived', updated_at = NOW() - WHERE id = $1 AND owner_id = $2 - "#, - ) - .bind(id) - .bind(owner_id) - .execute(pool) - .await?; - - Ok(result.rows_affected() > 0) -} - -/// Add a contract to a chain. -pub async fn add_contract_to_chain( - pool: &PgPool, - chain_id: Uuid, - contract_id: Uuid, - depends_on: Vec<Uuid>, - order_index: i32, - editor_x: Option<f64>, - editor_y: Option<f64>, -) -> Result<ChainContract, sqlx::Error> { - // Also update the contract's chain_id - sqlx::query("UPDATE contracts SET chain_id = $1 WHERE id = $2") - .bind(chain_id) - .bind(contract_id) - .execute(pool) - .await?; - - sqlx::query_as::<_, ChainContract>( + status: &str, +) -> Result<Directive, sqlx::Error> { + sqlx::query_as::<_, Directive>( r#" - INSERT INTO chain_contracts (chain_id, contract_id, depends_on, order_index, editor_x, editor_y) - VALUES ($1, $2, $3, $4, $5, $6) - ON CONFLICT (chain_id, contract_id) DO UPDATE SET - depends_on = EXCLUDED.depends_on, - order_index = EXCLUDED.order_index, - editor_x = EXCLUDED.editor_x, - editor_y = EXCLUDED.editor_y + UPDATE directives SET + status = $2, + started_at = CASE WHEN $2 = 'active' AND started_at IS NULL THEN NOW() ELSE started_at END, + completed_at = CASE WHEN $2 IN ('completed', 'failed', 'archived') THEN NOW() ELSE completed_at END, + updated_at = NOW() + WHERE id = $1 RETURNING * "#, ) - .bind(chain_id) - .bind(contract_id) - .bind(&depends_on) - .bind(order_index) - .bind(editor_x) - .bind(editor_y) + .bind(id) + .bind(status) .fetch_one(pool) .await } -/// Remove a contract from a chain. -pub async fn remove_contract_from_chain( +/// Archive a directive (soft delete). +pub async fn archive_directive_for_owner( pool: &PgPool, - chain_id: Uuid, - contract_id: Uuid, + id: Uuid, + owner_id: Uuid, ) -> Result<bool, sqlx::Error> { - // Clear the contract's chain_id - sqlx::query("UPDATE contracts SET chain_id = NULL WHERE id = $1 AND chain_id = $2") - .bind(contract_id) - .bind(chain_id) - .execute(pool) - .await?; - let result = sqlx::query( r#" - DELETE FROM chain_contracts - WHERE chain_id = $1 AND contract_id = $2 + UPDATE directives SET status = 'archived', updated_at = NOW() + WHERE id = $1 AND owner_id = $2 "#, ) - .bind(chain_id) - .bind(contract_id) + .bind(id) + .bind(owner_id) .execute(pool) .await?; - Ok(result.rows_affected() > 0) } -/// List contracts in a chain with their details. -pub async fn list_chain_contracts( - pool: &PgPool, - chain_id: Uuid, -) -> Result<Vec<ChainContractDetail>, sqlx::Error> { - sqlx::query_as::<_, ChainContractDetail>( - r#" - SELECT - cc.id as chain_contract_id, - cc.contract_id, - c.name as contract_name, - c.status as contract_status, - c.phase as contract_phase, - cc.depends_on, - cc.order_index, - cc.editor_x, - cc.editor_y, - cc.evaluation_status, - cc.evaluation_retry_count, - cc.max_evaluation_retries, - cc.created_at - FROM chain_contracts cc - JOIN contracts c ON c.id = cc.contract_id - WHERE cc.chain_id = $1 - ORDER BY cc.order_index ASC - "#, - ) - .bind(chain_id) - .fetch_all(pool) - .await -} - -/// Get chain with all contracts for detail view. -pub async fn get_chain_with_contracts( +/// Get directive with full progress info. +pub async fn get_directive_with_progress( pool: &PgPool, - chain_id: Uuid, + id: Uuid, owner_id: Uuid, -) -> Result<Option<ChainWithContracts>, sqlx::Error> { - let chain = get_chain_for_owner(pool, chain_id, owner_id).await?; - - match chain { - Some(chain) => { - let contracts = list_chain_contracts(pool, chain_id).await?; - let repositories = list_chain_repositories(pool, chain_id).await?; - Ok(Some(ChainWithContracts { - chain, - contracts, - repositories, - })) - } - None => Ok(None), - } -} +) -> Result<Option<DirectiveWithProgress>, sqlx::Error> { + let directive = match get_directive_for_owner(pool, id, owner_id).await? { + Some(d) => d, + None => return Ok(None), + }; -// ============================================================================= -// Chain Repository Operations -// ============================================================================= + let chain = if let Some(chain_id) = directive.current_chain_id { + get_directive_chain(pool, chain_id).await? + } else { + None + }; -/// List all repositories for a chain. -pub async fn list_chain_repositories( - pool: &PgPool, - chain_id: Uuid, -) -> Result<Vec<ChainRepository>, sqlx::Error> { - sqlx::query_as::<_, ChainRepository>( - r#" - SELECT * - FROM chain_repositories - WHERE chain_id = $1 - ORDER BY is_primary DESC, created_at ASC - "#, - ) - .bind(chain_id) - .fetch_all(pool) - .await -} + let steps = if let Some(ref c) = chain { + list_chain_steps(pool, c.id).await? + } else { + vec![] + }; -/// Get a chain repository by ID. -pub async fn get_chain_repository( - pool: &PgPool, - chain_id: Uuid, - repository_id: Uuid, -) -> Result<Option<ChainRepository>, sqlx::Error> { - sqlx::query_as::<_, ChainRepository>( - r#" - SELECT * - FROM chain_repositories - WHERE id = $1 AND chain_id = $2 - "#, - ) - .bind(repository_id) - .bind(chain_id) - .fetch_optional(pool) - .await + let recent_events = list_directive_events(pool, id, Some(20)).await?; + let pending_approvals = list_pending_approvals(pool, id).await?; + + Ok(Some(DirectiveWithProgress { + directive, + chain, + steps, + recent_events, + pending_approvals, + })) } -/// Add a repository to a chain. -pub async fn add_chain_repository( +// ============================================================================= +// Directive Chain Operations +// ============================================================================= + +/// Create a new chain generation for a directive. +pub async fn create_directive_chain( pool: &PgPool, - chain_id: Uuid, - req: &AddChainRepositoryRequest, -) -> Result<ChainRepository, sqlx::Error> { - // If is_primary, clear other primaries first - if req.is_primary { - sqlx::query( - r#" - UPDATE chain_repositories - SET is_primary = false, updated_at = NOW() - WHERE chain_id = $1 AND is_primary = true - "#, - ) - .bind(chain_id) - .execute(pool) - .await?; - } + directive_id: Uuid, + name: &str, + description: Option<&str>, + rationale: Option<&str>, + planning_model: Option<&str>, +) -> Result<DirectiveChain, sqlx::Error> { + // Get next generation number + let generation = sqlx::query_scalar::<_, i32>( + "SELECT COALESCE(MAX(generation), 0) + 1 FROM directive_chains WHERE directive_id = $1" + ) + .bind(directive_id) + .fetch_one(pool) + .await?; - sqlx::query_as::<_, ChainRepository>( + let chain = sqlx::query_as::<_, DirectiveChain>( r#" - INSERT INTO chain_repositories (chain_id, name, repository_url, local_path, source_type, status, is_primary) - VALUES ($1, $2, $3, $4, $5, 'ready', $6) + INSERT INTO directive_chains (directive_id, generation, name, description, rationale, planning_model) + VALUES ($1, $2, $3, $4, $5, $6) RETURNING * "#, ) - .bind(chain_id) - .bind(&req.name) - .bind(&req.repository_url) - .bind(&req.local_path) - .bind(&req.source_type) - .bind(req.is_primary) + .bind(directive_id) + .bind(generation) + .bind(name) + .bind(description) + .bind(rationale) + .bind(planning_model) .fetch_one(pool) - .await -} - -/// Delete a repository from a chain. -pub async fn delete_chain_repository( - pool: &PgPool, - chain_id: Uuid, - repository_id: Uuid, -) -> Result<bool, sqlx::Error> { - let result = sqlx::query( - r#" - DELETE FROM chain_repositories - WHERE id = $1 AND chain_id = $2 - "#, - ) - .bind(repository_id) - .bind(chain_id) - .execute(pool) .await?; - Ok(result.rows_affected() > 0) -} - -/// Set a repository as primary for a chain. -pub async fn set_chain_repository_primary( - pool: &PgPool, - chain_id: Uuid, - repository_id: Uuid, -) -> Result<ChainRepository, sqlx::Error> { - // Clear existing primary + // Update directive to point to new chain and increment generation count sqlx::query( r#" - UPDATE chain_repositories - SET is_primary = false, updated_at = NOW() - WHERE chain_id = $1 AND is_primary = true + UPDATE directives SET + current_chain_id = $2, + chain_generation_count = chain_generation_count + 1, + updated_at = NOW() + WHERE id = $1 "#, ) - .bind(chain_id) + .bind(directive_id) + .bind(chain.id) .execute(pool) .await?; - // Set new primary - sqlx::query_as::<_, ChainRepository>( - r#" - UPDATE chain_repositories - SET is_primary = true, updated_at = NOW() - WHERE id = $1 AND chain_id = $2 - RETURNING * - "#, - ) - .bind(repository_id) - .bind(chain_id) - .fetch_one(pool) - .await + Ok(chain) } -/// Get the primary repository for a chain. -pub async fn get_chain_primary_repository( - pool: &PgPool, - chain_id: Uuid, -) -> Result<Option<ChainRepository>, sqlx::Error> { - sqlx::query_as::<_, ChainRepository>( - r#" - SELECT * - FROM chain_repositories - WHERE chain_id = $1 AND is_primary = true - "#, +/// Get a directive chain by ID. +pub async fn get_directive_chain(pool: &PgPool, id: Uuid) -> Result<Option<DirectiveChain>, sqlx::Error> { + sqlx::query_as::<_, DirectiveChain>( + "SELECT * FROM directive_chains WHERE id = $1" ) - .bind(chain_id) + .bind(id) .fetch_optional(pool) .await } -/// Get chain graph structure for visualization. -pub async fn get_chain_graph( - pool: &PgPool, - chain_id: Uuid, -) -> Result<Option<ChainGraphResponse>, sqlx::Error> { - let chain = get_chain(pool, chain_id).await?; - - match chain { - Some(chain) => { - let contracts = list_chain_contracts(pool, chain_id).await?; - - let nodes: Vec<ChainGraphNode> = contracts - .iter() - .map(|c| ChainGraphNode { - id: c.chain_contract_id, - contract_id: c.contract_id, - name: c.contract_name.clone(), - status: c.contract_status.clone(), - phase: c.contract_phase.clone(), - x: c.editor_x.unwrap_or(0.0), - y: c.editor_y.unwrap_or(0.0), - }) - .collect(); - - let mut edges: Vec<ChainGraphEdge> = Vec::new(); - for contract in &contracts { - for dep_id in &contract.depends_on { - // Find the chain_contract_id for this dependency - if let Some(dep) = contracts.iter().find(|c| c.contract_id == *dep_id) { - edges.push(ChainGraphEdge { - from: dep.chain_contract_id, - to: contract.chain_contract_id, - }); - } - } - } - - Ok(Some(ChainGraphResponse { - chain_id: chain.id, - chain_name: chain.name, - chain_status: chain.status, - nodes, - edges, - })) - } - None => Ok(None), - } -} - -/// Record a chain event. -pub async fn record_chain_event( - pool: &PgPool, - chain_id: Uuid, - event_type: &str, - contract_id: Option<Uuid>, - event_data: Option<serde_json::Value>, -) -> Result<ChainEvent, sqlx::Error> { - sqlx::query_as::<_, ChainEvent>( +/// Get the current chain for a directive. +pub async fn get_current_chain(pool: &PgPool, directive_id: Uuid) -> Result<Option<DirectiveChain>, sqlx::Error> { + sqlx::query_as::<_, DirectiveChain>( r#" - INSERT INTO chain_events (chain_id, event_type, contract_id, event_data) - VALUES ($1, $2, $3, $4) - RETURNING * + SELECT dc.* FROM directive_chains dc + JOIN directives d ON d.current_chain_id = dc.id + WHERE d.id = $1 "#, ) - .bind(chain_id) - .bind(event_type) - .bind(contract_id) - .bind(event_data) - .fetch_one(pool) + .bind(directive_id) + .fetch_optional(pool) .await } -/// List chain events. -pub async fn list_chain_events( +/// Update chain status. +pub async fn update_chain_status( pool: &PgPool, chain_id: Uuid, -) -> Result<Vec<ChainEvent>, sqlx::Error> { - sqlx::query_as::<_, ChainEvent>( - r#" - SELECT * - FROM chain_events - WHERE chain_id = $1 - ORDER BY created_at DESC - "#, - ) - .bind(chain_id) - .fetch_all(pool) - .await -} - -/// Increment chain loop iteration. -pub async fn increment_chain_loop(pool: &PgPool, chain_id: Uuid) -> Result<Chain, sqlx::Error> { - sqlx::query_as::<_, Chain>( + status: &str, +) -> Result<DirectiveChain, sqlx::Error> { + sqlx::query_as::<_, DirectiveChain>( r#" - UPDATE chains - SET loop_current_iteration = COALESCE(loop_current_iteration, 0) + 1, + UPDATE directive_chains SET + status = $2, + started_at = CASE WHEN $2 = 'active' AND started_at IS NULL THEN NOW() ELSE started_at END, + completed_at = CASE WHEN $2 IN ('completed', 'failed', 'superseded') THEN NOW() ELSE completed_at END, updated_at = NOW() WHERE id = $1 RETURNING * "#, ) .bind(chain_id) + .bind(status) .fetch_one(pool) .await } -/// Mark a chain as completed. -pub async fn complete_chain(pool: &PgPool, chain_id: Uuid) -> Result<Chain, sqlx::Error> { - sqlx::query_as::<_, Chain>( +/// Supersede a chain (mark as superseded and update directive). +pub async fn supersede_chain(pool: &PgPool, chain_id: Uuid) -> Result<(), sqlx::Error> { + sqlx::query( r#" - UPDATE chains - SET status = 'completed', - updated_at = NOW() + UPDATE directive_chains SET status = 'superseded', completed_at = NOW(), updated_at = NOW() WHERE id = $1 - RETURNING * - "#, - ) - .bind(chain_id) - .fetch_one(pool) - .await -} - -/// Get contracts in a chain that have no pending dependencies (ready to start). -/// Returns contracts where all depends_on contracts are completed. -pub async fn get_ready_chain_contracts( - pool: &PgPool, - chain_id: Uuid, -) -> Result<Vec<ChainContractDetail>, sqlx::Error> { - sqlx::query_as::<_, ChainContractDetail>( - r#" - SELECT - cc.id as chain_contract_id, - cc.contract_id, - c.name as contract_name, - c.status as contract_status, - c.phase as contract_phase, - cc.depends_on, - cc.order_index, - cc.editor_x, - cc.editor_y - FROM chain_contracts cc - JOIN contracts c ON c.id = cc.contract_id - WHERE cc.chain_id = $1 - AND c.status = 'active' - AND ( - -- No dependencies - cc.depends_on IS NULL - OR array_length(cc.depends_on, 1) IS NULL - OR array_length(cc.depends_on, 1) = 0 - -- Or all dependencies completed - OR NOT EXISTS ( - SELECT 1 - FROM unnest(cc.depends_on) AS dep_id - JOIN contracts dep ON dep.id = dep_id - WHERE dep.status != 'completed' - ) - ) - ORDER BY cc.order_index ASC "#, ) .bind(chain_id) - .fetch_all(pool) - .await -} - -/// Check if all contracts in a chain are completed. -pub async fn is_chain_complete(pool: &PgPool, chain_id: Uuid) -> Result<bool, sqlx::Error> { - let result: (i64,) = sqlx::query_as( - r#" - SELECT COUNT(*) - FROM chain_contracts cc - JOIN contracts c ON c.id = cc.contract_id - WHERE cc.chain_id = $1 - AND c.status != 'completed' - "#, - ) - .bind(chain_id) - .fetch_one(pool) + .execute(pool) .await?; - - Ok(result.0 == 0) -} - -/// Get chain editor data for the GUI editor. -pub async fn get_chain_editor_data( - pool: &PgPool, - chain_id: Uuid, - owner_id: Uuid, -) -> Result<Option<ChainEditorData>, sqlx::Error> { - let chain = get_chain_for_owner(pool, chain_id, owner_id).await?; - - match chain { - Some(chain) => { - let contracts = list_chain_contracts(pool, chain_id).await?; - let repositories = list_chain_repositories(pool, chain_id).await?; - - // Build nodes - let nodes: Vec<ChainEditorNode> = contracts - .iter() - .map(|c| ChainEditorNode { - id: c.contract_id.to_string(), - x: c.editor_x.unwrap_or(0.0), - y: c.editor_y.unwrap_or(0.0), - contract: ChainEditorContract { - name: c.contract_name.clone(), - description: None, // Would need to join with full contract data - contract_type: "simple".to_string(), - phases: vec!["plan".to_string(), "execute".to_string()], - tasks: vec![], - deliverables: vec![], - }, - }) - .collect(); - - // Build edges - let edges: Vec<ChainEditorEdge> = contracts - .iter() - .flat_map(|c| { - c.depends_on.iter().map(move |dep_id| ChainEditorEdge { - from: dep_id.to_string(), - to: c.contract_id.to_string(), - }) - }) - .collect(); - - Ok(Some(ChainEditorData { - id: Some(chain.id), - name: chain.name, - description: chain.description, - repositories, - loop_enabled: chain.loop_enabled, - loop_max_iterations: chain.loop_max_iterations, - loop_progress_check: chain.loop_progress_check, - nodes, - edges, - })) - } - None => Ok(None), - } + Ok(()) } // ============================================================================= -// Chain Contract Definition Operations +// Chain Step Operations // ============================================================================= -/// Create a new contract definition in a chain. -pub async fn create_chain_contract_definition( +/// Create a new step in a chain. +pub async fn create_chain_step( pool: &PgPool, chain_id: Uuid, - req: AddContractDefinitionRequest, -) -> Result<ChainContractDefinition, sqlx::Error> { - // Get the next order index - let max_order: Option<i32> = sqlx::query_scalar( - "SELECT MAX(order_index) FROM chain_contract_definitions WHERE chain_id = $1", + req: AddStepRequest, +) -> Result<ChainStep, sqlx::Error> { + let step_type = req.step_type.unwrap_or_else(|| "execute".to_string()); + let contract_type = req.contract_type.unwrap_or_else(|| "simple".to_string()); + let phases = req.phases.unwrap_or_default(); + let depends_on = req.depends_on.unwrap_or_default(); + let requirement_ids = req.requirement_ids.unwrap_or_default(); + let acceptance_criteria_ids = req.acceptance_criteria_ids.unwrap_or_default(); + let verifier_config = req.verifier_config.unwrap_or(serde_json::json!({})); + + // Get next order index + let order_index = sqlx::query_scalar::<_, i32>( + "SELECT COALESCE(MAX(order_index), 0) + 1 FROM chain_steps WHERE chain_id = $1" ) .bind(chain_id) .fetch_one(pool) .await?; - let order_index = max_order.unwrap_or(-1) + 1; - - // Convert tasks, deliverables, and validation to JSON - let tasks_json = req.tasks.as_ref().map(|t| serde_json::to_value(t).unwrap()); - let deliverables_json = req - .deliverables - .as_ref() - .map(|d| serde_json::to_value(d).unwrap()); - let validation_json = req - .validation - .as_ref() - .map(|v| serde_json::to_value(v).unwrap()); - let depends_on_names: Vec<String> = req.depends_on.unwrap_or_default(); - - sqlx::query_as::<_, ChainContractDefinition>( - r#" - INSERT INTO chain_contract_definitions - (chain_id, name, description, contract_type, initial_phase, depends_on_names, tasks, deliverables, validation, editor_x, editor_y, order_index) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) + let step = sqlx::query_as::<_, ChainStep>( + r#" + INSERT INTO chain_steps ( + chain_id, name, description, step_type, contract_type, + initial_phase, task_plan, phases, depends_on, parallel_group, + requirement_ids, acceptance_criteria_ids, verifier_config, + editor_x, editor_y, order_index + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) RETURNING * "#, ) .bind(chain_id) .bind(&req.name) .bind(&req.description) - .bind(&req.contract_type) + .bind(&step_type) + .bind(&contract_type) .bind(&req.initial_phase) - .bind(&depends_on_names) - .bind(&tasks_json) - .bind(&deliverables_json) - .bind(&validation_json) - .bind(req.editor_x) - .bind(req.editor_y) + .bind(&req.task_plan) + .bind(&phases) + .bind(&depends_on) + .bind(&req.parallel_group) + .bind(&requirement_ids) + .bind(&acceptance_criteria_ids) + .bind(&verifier_config) + .bind(req.editor_x.unwrap_or(0.0)) + .bind(req.editor_y.unwrap_or(0.0)) .bind(order_index) .fetch_one(pool) - .await -} + .await?; -/// List all contract definitions in a chain. -pub async fn list_chain_contract_definitions( - pool: &PgPool, - chain_id: Uuid, -) -> Result<Vec<ChainContractDefinition>, sqlx::Error> { - sqlx::query_as::<_, ChainContractDefinition>( - r#" - SELECT * FROM chain_contract_definitions - WHERE chain_id = $1 - ORDER BY order_index ASC - "#, + // Update chain total_steps count + sqlx::query( + "UPDATE directive_chains SET total_steps = total_steps + 1, updated_at = NOW() WHERE id = $1" ) .bind(chain_id) - .fetch_all(pool) - .await + .execute(pool) + .await?; + + Ok(step) } -/// Get a specific contract definition. -pub async fn get_chain_contract_definition( - pool: &PgPool, - definition_id: Uuid, -) -> Result<Option<ChainContractDefinition>, sqlx::Error> { - sqlx::query_as::<_, ChainContractDefinition>( - "SELECT * FROM chain_contract_definitions WHERE id = $1", +/// Get a chain step by ID. +pub async fn get_chain_step(pool: &PgPool, id: Uuid) -> Result<Option<ChainStep>, sqlx::Error> { + sqlx::query_as::<_, ChainStep>( + "SELECT * FROM chain_steps WHERE id = $1" ) - .bind(definition_id) + .bind(id) .fetch_optional(pool) .await } -/// Update a contract definition. -pub async fn update_chain_contract_definition( - pool: &PgPool, - definition_id: Uuid, - req: UpdateContractDefinitionRequest, -) -> Result<ChainContractDefinition, sqlx::Error> { - let tasks_json = req.tasks.as_ref().map(|t| serde_json::to_value(t).unwrap()); - let deliverables_json = req - .deliverables - .as_ref() - .map(|d| serde_json::to_value(d).unwrap()); - let validation_json = req - .validation - .as_ref() - .map(|v| serde_json::to_value(v).unwrap()); +/// List all steps in a chain. +pub async fn list_chain_steps(pool: &PgPool, chain_id: Uuid) -> Result<Vec<ChainStep>, sqlx::Error> { + sqlx::query_as::<_, ChainStep>( + "SELECT * FROM chain_steps WHERE chain_id = $1 ORDER BY order_index" + ) + .bind(chain_id) + .fetch_all(pool) + .await +} - sqlx::query_as::<_, ChainContractDefinition>( +/// Update a chain step. +pub async fn update_chain_step( + pool: &PgPool, + step_id: Uuid, + req: UpdateStepRequest, +) -> Result<ChainStep, sqlx::Error> { + sqlx::query_as::<_, ChainStep>( r#" - UPDATE chain_contract_definitions SET + UPDATE chain_steps SET name = COALESCE($2, name), description = COALESCE($3, description), - contract_type = COALESCE($4, contract_type), - initial_phase = COALESCE($5, initial_phase), - depends_on_names = COALESCE($6, depends_on_names), - tasks = COALESCE($7, tasks), - deliverables = COALESCE($8, deliverables), - validation = COALESCE($9, validation), - editor_x = COALESCE($10, editor_x), - editor_y = COALESCE($11, editor_y) + task_plan = COALESCE($4, task_plan), + depends_on = COALESCE($5, depends_on), + requirement_ids = COALESCE($6, requirement_ids), + acceptance_criteria_ids = COALESCE($7, acceptance_criteria_ids), + verifier_config = COALESCE($8, verifier_config), + editor_x = COALESCE($9, editor_x), + editor_y = COALESCE($10, editor_y) WHERE id = $1 RETURNING * "#, ) - .bind(definition_id) + .bind(step_id) .bind(&req.name) .bind(&req.description) - .bind(&req.contract_type) - .bind(&req.initial_phase) + .bind(&req.task_plan) .bind(&req.depends_on) - .bind(&tasks_json) - .bind(&deliverables_json) - .bind(&validation_json) + .bind(&req.requirement_ids) + .bind(&req.acceptance_criteria_ids) + .bind(&req.verifier_config) .bind(req.editor_x) .bind(req.editor_y) .fetch_one(pool) .await } -/// Delete a contract definition. -pub async fn delete_chain_contract_definition( - pool: &PgPool, - definition_id: Uuid, -) -> Result<bool, sqlx::Error> { - let result = sqlx::query("DELETE FROM chain_contract_definitions WHERE id = $1") - .bind(definition_id) +/// Delete a chain step. +pub async fn delete_chain_step(pool: &PgPool, step_id: Uuid) -> Result<bool, sqlx::Error> { + // Get chain_id first for updating count + let chain_id = sqlx::query_scalar::<_, Uuid>( + "SELECT chain_id FROM chain_steps WHERE id = $1" + ) + .bind(step_id) + .fetch_optional(pool) + .await?; + + let result = sqlx::query("DELETE FROM chain_steps WHERE id = $1") + .bind(step_id) .execute(pool) .await?; + + // Update chain total_steps count + if let Some(cid) = chain_id { + sqlx::query( + "UPDATE directive_chains SET total_steps = total_steps - 1, updated_at = NOW() WHERE id = $1" + ) + .bind(cid) + .execute(pool) + .await?; + } + Ok(result.rows_affected() > 0) } -/// Get definitions that are ready to be instantiated (all dependencies are satisfied). -/// A definition is ready if all definitions it depends on have been instantiated as contracts -/// and those contracts have completed. -pub async fn get_ready_definitions( - pool: &PgPool, - chain_id: Uuid, -) -> Result<Vec<ChainContractDefinition>, sqlx::Error> { - sqlx::query_as::<_, ChainContractDefinition>( - r#" - SELECT d.* - FROM chain_contract_definitions d - WHERE d.chain_id = $1 - -- Not already instantiated - AND NOT EXISTS ( - SELECT 1 FROM chain_contracts cc - WHERE cc.definition_id = d.id - ) - -- All dependencies satisfied (either no deps, or all deps have completed contracts) - AND ( - cardinality(d.depends_on_names) = 0 - OR NOT EXISTS ( - SELECT 1 FROM unnest(d.depends_on_names) AS dep_name - WHERE NOT EXISTS ( - SELECT 1 FROM chain_contract_definitions dep_def - JOIN chain_contracts cc ON cc.definition_id = dep_def.id - JOIN contracts c ON c.id = cc.contract_id - WHERE dep_def.chain_id = d.chain_id - AND dep_def.name = dep_name - AND c.status = 'completed' - ) - ) - ) - ORDER BY d.order_index ASC +/// Find steps that are ready to execute (all dependencies met, status=pending). +pub async fn find_ready_steps(pool: &PgPool, chain_id: Uuid) -> Result<Vec<ChainStep>, sqlx::Error> { + sqlx::query_as::<_, ChainStep>( + r#" + SELECT s.* FROM chain_steps s + WHERE s.chain_id = $1 + AND s.status = 'pending' + AND NOT EXISTS ( + SELECT 1 FROM chain_steps dep + WHERE dep.id = ANY(s.depends_on) + AND dep.status NOT IN ('passed', 'skipped') + ) + ORDER BY s.order_index "#, ) .bind(chain_id) @@ -5772,909 +5533,500 @@ pub async fn get_ready_definitions( .await } -/// Get the definition graph for visualization. -pub async fn get_chain_definition_graph( +/// Update step status. +pub async fn update_step_status( pool: &PgPool, - chain_id: Uuid, -) -> Result<Option<ChainDefinitionGraphResponse>, sqlx::Error> { - let chain = sqlx::query_as::<_, Chain>("SELECT * FROM chains WHERE id = $1") - .bind(chain_id) - .fetch_optional(pool) - .await?; - - let Some(chain) = chain else { - return Ok(None); - }; - - let definitions = list_chain_contract_definitions(pool, chain_id).await?; - - // Get instantiated contracts for each definition - let chain_contracts = list_chain_contracts(pool, chain_id).await?; - let instantiated: std::collections::HashMap<Uuid, &ChainContractDetail> = chain_contracts - .iter() - .filter_map(|cc| { - // Find definition_id from cc - we need to query this - // For now, match by name - definitions - .iter() - .find(|d| d.name == cc.contract_name) - .map(|d| (d.id, cc)) - }) - .collect(); - - let nodes: Vec<ChainDefinitionGraphNode> = definitions - .iter() - .map(|d| { - let cc = instantiated.get(&d.id); - ChainDefinitionGraphNode { - id: d.id, - name: d.name.clone(), - contract_type: d.contract_type.clone(), - x: d.editor_x.unwrap_or(0.0), - y: d.editor_y.unwrap_or(0.0), - is_instantiated: cc.is_some(), - contract_id: cc.map(|c| c.contract_id), - contract_status: cc.map(|c| c.contract_status.clone()), - } - }) - .collect(); - - // Build edges from depends_on_names - let name_to_id: std::collections::HashMap<&str, Uuid> = - definitions.iter().map(|d| (d.name.as_str(), d.id)).collect(); - - let edges: Vec<ChainGraphEdge> = definitions - .iter() - .flat_map(|d| { - let target_id = d.id; - let name_to_id = &name_to_id; - d.depends_on_names.iter().filter_map(move |dep_name| { - name_to_id - .get(dep_name.as_str()) - .map(|&from_id| ChainGraphEdge { from: from_id, to: target_id }) - }) - }) - .collect(); - - Ok(Some(ChainDefinitionGraphResponse { - chain_id: chain.id, - chain_name: chain.name, - chain_status: chain.status, - nodes, - edges, - })) -} - -/// Update chain status. -pub async fn update_chain_status( - pool: &PgPool, - chain_id: Uuid, + step_id: Uuid, status: &str, -) -> Result<(), sqlx::Error> { - sqlx::query("UPDATE chains SET status = $2, updated_at = NOW() WHERE id = $1") - .bind(chain_id) - .bind(status) - .execute(pool) - .await?; - Ok(()) -} - -// ============================================================================= -// Chain Progression -// ============================================================================= - -/// Result of chain progression check -#[derive(Debug)] -pub struct ChainProgressionResult { - /// Contracts created from ready definitions - pub contracts_created: Vec<Uuid>, - /// Whether all definitions are instantiated and completed (chain is done) - pub chain_completed: bool, -} - -/// Progress a chain by creating contracts from ready definitions. -/// -/// This is called when a contract in the chain completes. It: -/// 1. Finds definitions whose dependencies are all satisfied (completed) -/// 2. Creates contracts from those definitions -/// 3. Links them to the chain -/// 4. Checks if chain is complete (all definitions instantiated and completed) -pub async fn progress_chain( - pool: &PgPool, - chain_id: Uuid, - owner_id: Uuid, -) -> Result<ChainProgressionResult, sqlx::Error> { - let mut contracts_created = Vec::new(); - - // Get all definitions for this chain - let definitions = list_chain_contract_definitions(pool, chain_id).await?; - if definitions.is_empty() { - return Ok(ChainProgressionResult { - contracts_created: vec![], - chain_completed: true, - }); - } - - // Get existing chain contracts to know what's already instantiated - let chain_contracts = list_chain_contracts(pool, chain_id).await?; - - // Build a map of definition name -> instantiated contract status - let instantiated: std::collections::HashMap<String, Option<String>> = chain_contracts - .iter() - .map(|cc| (cc.contract_name.clone(), Some(cc.contract_status.clone()))) - .collect(); - - // Find definitions that are ready to be instantiated: - // - Not yet instantiated - // - All dependencies are instantiated AND completed - for def in &definitions { - // Skip if already instantiated - if instantiated.contains_key(&def.name) { - continue; - } - - // Check if all dependencies are completed - let deps_satisfied = def.depends_on_names.iter().all(|dep_name| { - instantiated - .get(dep_name) - .map(|status| status.as_deref() == Some("completed")) - .unwrap_or(false) - }); - - // Root definitions (no dependencies) are always ready - let is_root = def.depends_on_names.is_empty(); - - if is_root || deps_satisfied { - // Create contract from definition - match create_contract_from_definition(pool, chain_id, owner_id, def).await { - Ok(contract_id) => { - contracts_created.push(contract_id); - tracing::info!( - chain_id = %chain_id, - definition_name = %def.name, - contract_id = %contract_id, - "Created contract from chain definition" - ); - } - Err(e) => { - tracing::error!( - chain_id = %chain_id, - definition_name = %def.name, - error = %e, - "Failed to create contract from chain definition" - ); - } - } - } - } - - // Check if chain is complete (all definitions instantiated and completed) - let updated_contracts = list_chain_contracts(pool, chain_id).await?; - let all_instantiated = definitions.len() == updated_contracts.len(); - let all_completed = updated_contracts - .iter() - .all(|cc| cc.contract_status == "completed"); - let chain_completed = all_instantiated && all_completed; - - if chain_completed { - update_chain_status(pool, chain_id, "completed").await?; - tracing::info!(chain_id = %chain_id, "Chain completed - all contracts done"); - } - - Ok(ChainProgressionResult { - contracts_created, - chain_completed, - }) -} - -/// Task definition parsed from JSON (matches chain YAML format) -#[derive(Debug, Clone, serde::Deserialize)] -struct ChainTaskDef { - name: String, - plan: String, -} - -/// Validation config parsed from definition JSON -#[derive(Debug, Clone, serde::Deserialize)] -#[serde(rename_all = "camelCase")] -struct ValidationConfig { - #[serde(default)] - check_deliverables: bool, - #[serde(default)] - run_tests: bool, - check_content: Option<String>, - #[serde(default = "default_on_failure_str")] - on_failure: String, - #[serde(default = "default_max_retries_val")] - max_retries: i32, -} - -fn default_on_failure_str() -> String { - "block".to_string() -} - -fn default_max_retries_val() -> i32 { - 3 -} - -/// Generate a validation plan for a checkpoint contract. -fn generate_checkpoint_plan( - def: &ChainContractDefinition, - upstream_contracts: &[&ChainContractDetail], - validation: &ValidationConfig, -) -> String { - let upstream_names: Vec<&str> = upstream_contracts.iter().map(|c| c.contract_name.as_str()).collect(); - - let mut plan = format!( - r#"# Checkpoint Validation: {} - -You are validating the outputs of upstream contracts before allowing downstream work to proceed. - -## Upstream Contracts to Validate -{} - -"#, - def.name, - upstream_names.iter().map(|n| format!("- {}", n)).collect::<Vec<_>>().join("\n") - ); - - // Add deliverables check section - if validation.check_deliverables { - plan.push_str(r#"## Deliverables Check -Verify that all required deliverables from upstream contracts exist and are properly completed. - -Use the makima CLI to check contract status: -```bash -makima contract status <contract_id> -``` - -For each upstream contract, verify: -1. Contract status is "completed" -2. All required deliverables are marked as complete -3. Deliverable content exists and is not empty - -"#); - } - - // Add tests check section - if validation.run_tests { - plan.push_str(r#"## Tests Check -Run the test suite to verify the codebase is in a good state. - -```bash -# Run tests appropriate for the project type -npm test # for Node.js projects -cargo test # for Rust projects -pytest # for Python projects -go test ./... # for Go projects -``` - -Verify: -1. All tests pass -2. No new test failures introduced -3. Test coverage is acceptable - -"#); - } - - // Add custom content check section - if let Some(content_check) = &validation.check_content { - plan.push_str(&format!(r#"## Custom Validation Criteria -{} - -"#, content_check)); - } - - // Add validation result section - plan.push_str(&format!(r#"## Reporting Results - -After completing all validation checks, you must report the result: - -**If ALL checks pass:** -Mark this checkpoint contract as completed using: -```bash -makima supervisor complete -``` - -**If ANY check fails (on_failure: "{}"):** -"#, validation.on_failure)); - - match validation.on_failure.as_str() { - "block" => plan.push_str(r#" -- Document the failure reason clearly -- Do NOT mark the contract as complete -- The chain will be blocked until issues are resolved manually -"#), - "retry" => plan.push_str(&format!(r#" -- Document the failure reason -- Request retry of the failed upstream contract (max {} retries) -- Use: `makima supervisor ask "Upstream validation failed. Retry?" --choices "Yes,No"` -"#, validation.max_retries)), - "warn" => plan.push_str(r#" -- Document the warning/issue found -- Mark the contract as complete anyway (downstream will proceed) -- Log the warning for visibility -"#), - _ => plan.push_str(r#" -- Document the failure reason -- Do NOT mark the contract as complete -"#), - } - - plan.push_str(r#" -## Begin Validation - -Start by checking the status of each upstream contract, then proceed with the validation criteria above. -"#); - - plan -} - -/// Create a contract from a chain definition. -async fn create_contract_from_definition( - pool: &PgPool, - chain_id: Uuid, - owner_id: Uuid, - def: &ChainContractDefinition, -) -> Result<Uuid, sqlx::Error> { - // Get the existing contracts to find dependency info - let existing_contracts = list_chain_contracts(pool, chain_id).await?; - let name_to_contract: std::collections::HashMap<&str, &ChainContractDetail> = existing_contracts - .iter() - .map(|cc| (cc.contract_name.as_str(), cc)) - .collect(); - - // Resolve dependency names to contract details - let upstream_contracts: Vec<&ChainContractDetail> = def - .depends_on_names - .iter() - .filter_map(|name| name_to_contract.get(name.as_str()).copied()) - .collect(); - - // Create the contract request with basic fields - let req = CreateContractRequest { - name: def.name.clone(), - description: def.description.clone(), - contract_type: Some(def.contract_type.clone()), - initial_phase: def.initial_phase.clone(), - template_id: None, - autonomous_loop: None, - phase_guard: None, - local_only: None, - auto_merge_local: None, - }; - - // Create the contract - let contract = create_contract_for_owner(pool, owner_id, req).await?; - - // For checkpoint contracts, generate a validation plan - if def.contract_type == "checkpoint" { - // Parse validation config - let validation: ValidationConfig = def - .validation - .as_ref() - .and_then(|v| serde_json::from_value(v.clone()).ok()) - .unwrap_or(ValidationConfig { - check_deliverables: true, - run_tests: false, - check_content: None, - on_failure: default_on_failure_str(), - max_retries: default_max_retries_val(), - }); - - // Generate validation plan - let validation_plan = generate_checkpoint_plan(def, &upstream_contracts, &validation); - - // Create a supervisor task with the validation plan - let task_req = CreateTaskRequest { - contract_id: Some(contract.id), - name: format!("Validate: {}", def.name), - description: Some("Checkpoint validation task".to_string()), - plan: validation_plan, - parent_task_id: None, - is_supervisor: true, // Checkpoint uses supervisor task for validation - priority: 0, - repository_url: None, - base_branch: None, - target_branch: None, - merge_mode: None, - target_repo_path: None, - completion_action: None, - continue_from_task_id: None, - copy_files: None, - checkpoint_sha: None, - branched_from_task_id: None, - conversation_history: None, - supervisor_worktree_task_id: None, - }; - - if let Err(e) = create_task_for_owner(pool, owner_id, task_req).await { - tracing::warn!( - contract_id = %contract.id, - error = %e, - "Failed to create validation task for checkpoint contract" - ); - } +) -> Result<ChainStep, sqlx::Error> { + let step = sqlx::query_as::<_, ChainStep>( + r#" + UPDATE chain_steps SET + status = $2, + started_at = CASE WHEN $2 = 'running' AND started_at IS NULL THEN NOW() ELSE started_at END, + completed_at = CASE WHEN $2 IN ('passed', 'failed', 'skipped') THEN NOW() ELSE completed_at END + WHERE id = $1 + RETURNING * + "#, + ) + .bind(step_id) + .bind(status) + .fetch_one(pool) + .await?; - // Set initial validation status + // Update chain completed_steps and failed_steps counts + if status == "passed" || status == "skipped" { sqlx::query( - "UPDATE chain_contracts SET validation_status = 'pending' WHERE chain_id = $1 AND contract_id = $2", + "UPDATE directive_chains SET completed_steps = completed_steps + 1, updated_at = NOW() WHERE id = $1" ) - .bind(chain_id) - .bind(contract.id) + .bind(step.chain_id) .execute(pool) .await?; - } else { - // Parse and create tasks from definition for regular contracts - if let Some(tasks_json) = &def.tasks { - if let Ok(tasks) = serde_json::from_value::<Vec<ChainTaskDef>>(tasks_json.clone()) { - for task_def in tasks { - let task_req = CreateTaskRequest { - contract_id: Some(contract.id), - name: task_def.name, - description: None, - plan: task_def.plan, - parent_task_id: None, - is_supervisor: false, - priority: 0, - repository_url: None, - base_branch: None, - target_branch: None, - merge_mode: None, - target_repo_path: None, - completion_action: None, - continue_from_task_id: None, - copy_files: None, - checkpoint_sha: None, - branched_from_task_id: None, - conversation_history: None, - supervisor_worktree_task_id: None, - }; - if let Err(e) = create_task_for_owner(pool, owner_id, task_req).await { - tracing::warn!( - contract_id = %contract.id, - error = %e, - "Failed to create task from chain definition" - ); - } - } - } - } - } - - // Resolve dependency names to contract IDs - let depends_on: Vec<Uuid> = upstream_contracts.iter().map(|c| c.contract_id).collect(); - - // Link contract to chain - add_contract_to_chain( - pool, - chain_id, - contract.id, - depends_on, - def.order_index, - def.editor_x, - def.editor_y, - ) - .await?; - - // Update chain_contracts with definition_id link - sqlx::query( - "UPDATE chain_contracts SET definition_id = $1 WHERE chain_id = $2 AND contract_id = $3", - ) - .bind(def.id) - .bind(chain_id) - .bind(contract.id) - .execute(pool) - .await?; - - // Copy repositories from chain to contract - let chain_repos = list_chain_repositories(pool, chain_id).await.unwrap_or_default(); - for repo in chain_repos { - if let Some(url) = &repo.repository_url { - // Remote repository - if let Err(e) = add_remote_repository(pool, contract.id, &repo.name, url, repo.is_primary).await { - tracing::warn!( - contract_id = %contract.id, - repo_name = %repo.name, - error = %e, - "Failed to copy repository from chain to contract" - ); - } - } else if let Some(path) = &repo.local_path { - // Local repository - if let Err(e) = add_local_repository(pool, contract.id, &repo.name, path, repo.is_primary).await { - tracing::warn!( - contract_id = %contract.id, - repo_name = %repo.name, - error = %e, - "Failed to copy local repository from chain to contract" - ); - } - } - } - - // Activate the contract so it can start - sqlx::query("UPDATE contracts SET status = 'active' WHERE id = $1") - .bind(contract.id) + } else if status == "failed" { + sqlx::query( + "UPDATE directive_chains SET failed_steps = failed_steps + 1, updated_at = NOW() WHERE id = $1" + ) + .bind(step.chain_id) .execute(pool) .await?; + } - tracing::info!( - contract_id = %contract.id, - contract_name = %def.name, - chain_id = %chain_id, - "Contract created and activated from chain definition" - ); - - Ok(contract.id) + Ok(step) } -// ============================================================================= -// Chain Directives -// ============================================================================= - -/// Create a directive for a chain. -pub async fn create_chain_directive( +/// Link a step to a contract. +pub async fn update_step_contract( pool: &PgPool, - chain_id: Uuid, - req: CreateChainDirectiveRequest, -) -> Result<ChainDirective, sqlx::Error> { - let requirements = serde_json::to_value(&req.requirements.unwrap_or_default()) - .unwrap_or(serde_json::json!([])); - let acceptance_criteria = serde_json::to_value(&req.acceptance_criteria.unwrap_or_default()) - .unwrap_or(serde_json::json!([])); - let constraints = - serde_json::to_value(&req.constraints.unwrap_or_default()).unwrap_or(serde_json::json!([])); - let external_dependencies = - serde_json::to_value(&req.external_dependencies.unwrap_or_default()) - .unwrap_or(serde_json::json!([])); - let source_type = req.source_type.unwrap_or_else(|| "llm_generated".to_string()); - - sqlx::query_as::<_, ChainDirective>( - r#" - INSERT INTO chain_directives (chain_id, requirements, acceptance_criteria, constraints, external_dependencies, source_type) - VALUES ($1, $2, $3, $4, $5, $6) + step_id: Uuid, + contract_id: Uuid, + supervisor_task_id: Option<Uuid>, +) -> Result<ChainStep, sqlx::Error> { + sqlx::query_as::<_, ChainStep>( + r#" + UPDATE chain_steps SET contract_id = $2, supervisor_task_id = $3 + WHERE id = $1 RETURNING * "#, ) - .bind(chain_id) - .bind(&requirements) - .bind(&acceptance_criteria) - .bind(&constraints) - .bind(&external_dependencies) - .bind(&source_type) + .bind(step_id) + .bind(contract_id) + .bind(supervisor_task_id) .fetch_one(pool) .await } -/// Get the directive for a chain. -pub async fn get_chain_directive( +/// Update step confidence score and level. +pub async fn update_step_confidence( pool: &PgPool, - chain_id: Uuid, -) -> Result<Option<ChainDirective>, sqlx::Error> { - sqlx::query_as::<_, ChainDirective>( + step_id: Uuid, + score: f64, + level: &str, + evaluation_id: Uuid, +) -> Result<ChainStep, sqlx::Error> { + sqlx::query_as::<_, ChainStep>( r#" - SELECT * - FROM chain_directives - WHERE chain_id = $1 + UPDATE chain_steps SET + confidence_score = $2, + confidence_level = $3, + last_evaluation_id = $4, + evaluation_count = evaluation_count + 1 + WHERE id = $1 + RETURNING * "#, ) - .bind(chain_id) - .fetch_optional(pool) + .bind(step_id) + .bind(score) + .bind(level) + .bind(evaluation_id) + .fetch_one(pool) .await } -/// Update a chain directive. -pub async fn update_chain_directive( - pool: &PgPool, - chain_id: Uuid, - req: CreateChainDirectiveRequest, -) -> Result<ChainDirective, sqlx::Error> { - let requirements = req - .requirements - .map(|r| serde_json::to_value(&r).unwrap_or(serde_json::json!([]))); - let acceptance_criteria = req - .acceptance_criteria - .map(|ac| serde_json::to_value(&ac).unwrap_or(serde_json::json!([]))); - let constraints = req - .constraints - .map(|c| serde_json::to_value(&c).unwrap_or(serde_json::json!([]))); - let external_dependencies = req - .external_dependencies - .map(|ed| serde_json::to_value(&ed).unwrap_or(serde_json::json!([]))); - - sqlx::query_as::<_, ChainDirective>( - r#" - UPDATE chain_directives SET - requirements = COALESCE($2, requirements), - acceptance_criteria = COALESCE($3, acceptance_criteria), - constraints = COALESCE($4, constraints), - external_dependencies = COALESCE($5, external_dependencies), - source_type = COALESCE($6, source_type), - version = version + 1, - updated_at = NOW() - WHERE chain_id = $1 +/// Increment step rework count. +pub async fn increment_step_rework_count(pool: &PgPool, step_id: Uuid) -> Result<ChainStep, sqlx::Error> { + sqlx::query_as::<_, ChainStep>( + r#" + UPDATE chain_steps SET rework_count = rework_count + 1, status = 'rework' + WHERE id = $1 RETURNING * "#, ) - .bind(chain_id) - .bind(&requirements) - .bind(&acceptance_criteria) - .bind(&constraints) - .bind(&external_dependencies) - .bind(&req.source_type) + .bind(step_id) .fetch_one(pool) .await } -/// Delete a chain directive. -pub async fn delete_chain_directive(pool: &PgPool, chain_id: Uuid) -> Result<bool, sqlx::Error> { - let result = sqlx::query("DELETE FROM chain_directives WHERE chain_id = $1") - .bind(chain_id) - .execute(pool) - .await?; - Ok(result.rows_affected() > 0) -} - -/// Get directive traceability (requirement -> contract mapping). -pub async fn get_directive_traceability( +/// Get chain graph for visualization. +pub async fn get_chain_graph( pool: &PgPool, chain_id: Uuid, -) -> Result<DirectiveTraceabilityResponse, sqlx::Error> { - // Get the directive - let directive = get_chain_directive(pool, chain_id).await?; - - // Get all contract definitions with their requirement mappings - let definitions = list_chain_contract_definitions(pool, chain_id).await?; - - // Parse requirements from directive - let requirements: Vec<super::models::DirectiveRequirement> = directive - .as_ref() - .and_then(|d| serde_json::from_value(d.requirements.clone()).ok()) - .unwrap_or_default(); - - // Build traceability entries - let mut entries: Vec<TraceabilityEntry> = Vec::new(); - let mut covered_requirements: std::collections::HashSet<String> = - std::collections::HashSet::new(); - - for req in &requirements { - let mut contract_def_ids: Vec<Uuid> = Vec::new(); - let mut contract_def_names: Vec<String> = Vec::new(); - - for def in &definitions { - if def.requirement_ids.contains(&req.id) { - contract_def_ids.push(def.id); - contract_def_names.push(def.name.clone()); - covered_requirements.insert(req.id.clone()); - } +) -> Result<DirectiveChainGraphResponse, sqlx::Error> { + let chain = get_directive_chain(pool, chain_id).await? + .ok_or_else(|| sqlx::Error::RowNotFound)?; + + let steps = list_chain_steps(pool, chain_id).await?; + + let nodes: Vec<DirectiveChainGraphNode> = steps.iter().map(|s| { + DirectiveChainGraphNode { + id: s.id, + name: s.name.clone(), + step_type: s.step_type.clone(), + status: s.status.clone(), + confidence_score: s.confidence_score, + confidence_level: s.confidence_level.clone(), + contract_id: s.contract_id, + editor_x: s.editor_x, + editor_y: s.editor_y, + } + }).collect(); + + let mut edges = Vec::new(); + for step in &steps { + for dep_id in &step.depends_on { + edges.push(DirectiveChainGraphEdge { + source: *dep_id, + target: step.id, + }); } - - // Get acceptance criteria for this requirement - let acceptance_criteria: Vec<super::models::DirectiveAcceptanceCriterion> = directive - .as_ref() - .and_then(|d| serde_json::from_value(d.acceptance_criteria.clone()).ok()) - .unwrap_or_default(); - - let ac_ids: Vec<String> = acceptance_criteria - .iter() - .filter(|ac| ac.requirement_ids.contains(&req.id)) - .map(|ac| ac.id.clone()) - .collect(); - - entries.push(TraceabilityEntry { - requirement_id: req.id.clone(), - requirement_title: req.title.clone(), - contract_definition_ids: contract_def_ids, - contract_definition_names: contract_def_names, - acceptance_criteria_ids: ac_ids, - }); } - // Find uncovered requirements - let uncovered: Vec<String> = requirements - .iter() - .filter(|r| !covered_requirements.contains(&r.id)) - .map(|r| r.id.clone()) - .collect(); - - Ok(DirectiveTraceabilityResponse { + Ok(DirectiveChainGraphResponse { chain_id, - entries, - uncovered_requirements: uncovered, + directive_id: chain.directive_id, + nodes, + edges, }) } // ============================================================================= -// Contract Evaluations +// Directive Evaluation Operations // ============================================================================= -/// Create a contract evaluation record. -pub async fn create_contract_evaluation( +/// Create a directive evaluation. +pub async fn create_directive_evaluation( pool: &PgPool, - req: CreateContractEvaluationRequest, -) -> Result<ContractEvaluation, sqlx::Error> { - let criteria_results = serde_json::to_value(&req.criteria_results).unwrap_or(serde_json::json!([])); + directive_id: Uuid, + chain_id: Option<Uuid>, + step_id: Option<Uuid>, + contract_id: Option<Uuid>, + evaluation_type: &str, + evaluator: Option<&str>, + passed: bool, + overall_score: Option<f64>, + confidence_level: Option<&str>, + programmatic_results: serde_json::Value, + llm_results: serde_json::Value, + criteria_results: serde_json::Value, + summary_feedback: &str, + rework_instructions: Option<&str>, +) -> Result<DirectiveEvaluation, sqlx::Error> { + // Get next evaluation number for this step/directive + let evaluation_number = if let Some(sid) = step_id { + sqlx::query_scalar::<_, i32>( + "SELECT COALESCE(MAX(evaluation_number), 0) + 1 FROM directive_evaluations WHERE step_id = $1" + ) + .bind(sid) + .fetch_one(pool) + .await? + } else { + sqlx::query_scalar::<_, i32>( + "SELECT COALESCE(MAX(evaluation_number), 0) + 1 FROM directive_evaluations WHERE directive_id = $1 AND step_id IS NULL" + ) + .bind(directive_id) + .fetch_one(pool) + .await? + }; - sqlx::query_as::<_, ContractEvaluation>( + sqlx::query_as::<_, DirectiveEvaluation>( r#" - INSERT INTO contract_evaluations ( - contract_id, chain_id, chain_contract_id, - evaluator_model, passed, overall_score, - criteria_results, summary_feedback, rework_instructions, + INSERT INTO directive_evaluations ( + directive_id, chain_id, step_id, contract_id, + evaluation_type, evaluation_number, evaluator, + passed, overall_score, confidence_level, + programmatic_results, llm_results, criteria_results, + summary_feedback, rework_instructions, completed_at ) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW()) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, NOW()) RETURNING * "#, ) - .bind(req.contract_id) - .bind(req.chain_id) - .bind(req.chain_contract_id) - .bind(&req.evaluator_model) - .bind(req.passed) - .bind(req.overall_score) + .bind(directive_id) + .bind(chain_id) + .bind(step_id) + .bind(contract_id) + .bind(evaluation_type) + .bind(evaluation_number) + .bind(evaluator) + .bind(passed) + .bind(overall_score) + .bind(confidence_level) + .bind(&programmatic_results) + .bind(&llm_results) .bind(&criteria_results) - .bind(&req.summary_feedback) - .bind(&req.rework_instructions) + .bind(summary_feedback) + .bind(rework_instructions) .fetch_one(pool) .await } -/// Get a contract evaluation by ID. -pub async fn get_contract_evaluation( +/// List evaluations for a step. +pub async fn list_step_evaluations( pool: &PgPool, - id: Uuid, -) -> Result<Option<ContractEvaluation>, sqlx::Error> { - sqlx::query_as::<_, ContractEvaluation>( - r#" - SELECT * - FROM contract_evaluations - WHERE id = $1 - "#, + step_id: Uuid, +) -> Result<Vec<DirectiveEvaluation>, sqlx::Error> { + sqlx::query_as::<_, DirectiveEvaluation>( + "SELECT * FROM directive_evaluations WHERE step_id = $1 ORDER BY evaluation_number DESC" ) - .bind(id) - .fetch_optional(pool) + .bind(step_id) + .fetch_all(pool) .await } -/// List evaluations for a contract. -pub async fn list_contract_evaluations( +/// List evaluations for a directive. +pub async fn list_directive_evaluations( pool: &PgPool, - contract_id: Uuid, -) -> Result<Vec<ContractEvaluationSummary>, sqlx::Error> { - sqlx::query_as::<_, ContractEvaluationSummary>( - r#" - SELECT id, contract_id, evaluation_number, passed, overall_score, summary_feedback, created_at - FROM contract_evaluations - WHERE contract_id = $1 - ORDER BY evaluation_number DESC - "#, + directive_id: Uuid, + limit: Option<i64>, +) -> Result<Vec<DirectiveEvaluation>, sqlx::Error> { + let limit = limit.unwrap_or(100); + sqlx::query_as::<_, DirectiveEvaluation>( + "SELECT * FROM directive_evaluations WHERE directive_id = $1 ORDER BY created_at DESC LIMIT $2" ) - .bind(contract_id) + .bind(directive_id) + .bind(limit) .fetch_all(pool) .await } -/// List evaluations for a chain. -pub async fn list_chain_evaluations( +// ============================================================================= +// Directive Event Operations +// ============================================================================= + +/// Emit a directive event. +pub async fn emit_directive_event( pool: &PgPool, - chain_id: Uuid, -) -> Result<Vec<ContractEvaluationSummary>, sqlx::Error> { - sqlx::query_as::<_, ContractEvaluationSummary>( + directive_id: Uuid, + chain_id: Option<Uuid>, + step_id: Option<Uuid>, + event_type: &str, + severity: &str, + event_data: Option<serde_json::Value>, + actor_type: &str, + actor_id: Option<Uuid>, +) -> Result<DirectiveEvent, sqlx::Error> { + sqlx::query_as::<_, DirectiveEvent>( r#" - SELECT id, contract_id, evaluation_number, passed, overall_score, summary_feedback, created_at - FROM contract_evaluations - WHERE chain_id = $1 - ORDER BY created_at DESC + INSERT INTO directive_events ( + directive_id, chain_id, step_id, event_type, severity, event_data, actor_type, actor_id + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8) + RETURNING * "#, ) + .bind(directive_id) .bind(chain_id) + .bind(step_id) + .bind(event_type) + .bind(severity) + .bind(event_data) + .bind(actor_type) + .bind(actor_id) + .fetch_one(pool) + .await +} + +/// List directive events. +pub async fn list_directive_events( + pool: &PgPool, + directive_id: Uuid, + limit: Option<i64>, +) -> Result<Vec<DirectiveEvent>, sqlx::Error> { + let limit = limit.unwrap_or(100); + sqlx::query_as::<_, DirectiveEvent>( + "SELECT * FROM directive_events WHERE directive_id = $1 ORDER BY created_at DESC LIMIT $2" + ) + .bind(directive_id) + .bind(limit) + .fetch_all(pool) + .await +} + +// ============================================================================= +// Directive Verifier Operations +// ============================================================================= + +/// Create a directive verifier. +pub async fn create_directive_verifier( + pool: &PgPool, + directive_id: Uuid, + name: &str, + verifier_type: &str, + command: Option<&str>, + working_directory: Option<&str>, + auto_detect: bool, + detect_files: Vec<String>, + weight: f64, + required: bool, +) -> Result<DirectiveVerifier, sqlx::Error> { + sqlx::query_as::<_, DirectiveVerifier>( + r#" + INSERT INTO directive_verifiers ( + directive_id, name, verifier_type, command, working_directory, + auto_detect, detect_files, weight, required + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) + RETURNING * + "#, + ) + .bind(directive_id) + .bind(name) + .bind(verifier_type) + .bind(command) + .bind(working_directory) + .bind(auto_detect) + .bind(&detect_files) + .bind(weight) + .bind(required) + .fetch_one(pool) + .await +} + +/// List verifiers for a directive. +pub async fn list_directive_verifiers( + pool: &PgPool, + directive_id: Uuid, +) -> Result<Vec<DirectiveVerifier>, sqlx::Error> { + sqlx::query_as::<_, DirectiveVerifier>( + "SELECT * FROM directive_verifiers WHERE directive_id = $1 ORDER BY name" + ) + .bind(directive_id) .fetch_all(pool) .await } -/// Get the latest evaluation for a chain contract. -pub async fn get_latest_chain_contract_evaluation( +/// Update a directive verifier. +pub async fn update_directive_verifier( pool: &PgPool, - chain_contract_id: Uuid, -) -> Result<Option<ContractEvaluation>, sqlx::Error> { - sqlx::query_as::<_, ContractEvaluation>( + verifier_id: Uuid, + enabled: Option<bool>, + command: Option<&str>, + weight: Option<f64>, + required: Option<bool>, +) -> Result<DirectiveVerifier, sqlx::Error> { + sqlx::query_as::<_, DirectiveVerifier>( r#" - SELECT * - FROM contract_evaluations - WHERE chain_contract_id = $1 - ORDER BY evaluation_number DESC - LIMIT 1 + UPDATE directive_verifiers SET + enabled = COALESCE($2, enabled), + command = COALESCE($3, command), + weight = COALESCE($4, weight), + required = COALESCE($5, required), + updated_at = NOW() + WHERE id = $1 + RETURNING * "#, ) - .bind(chain_contract_id) - .fetch_optional(pool) + .bind(verifier_id) + .bind(enabled) + .bind(command) + .bind(weight) + .bind(required) + .fetch_one(pool) .await } -/// Get the next evaluation number for a chain contract. -pub async fn get_next_evaluation_number( +/// Update verifier last run result. +pub async fn update_verifier_result( pool: &PgPool, - chain_contract_id: Uuid, -) -> Result<i32, sqlx::Error> { - let result: Option<(i32,)> = sqlx::query_as( + verifier_id: Uuid, + result: serde_json::Value, +) -> Result<DirectiveVerifier, sqlx::Error> { + sqlx::query_as::<_, DirectiveVerifier>( r#" - SELECT COALESCE(MAX(evaluation_number), 0) + 1 as next_number - FROM contract_evaluations - WHERE chain_contract_id = $1 + UPDATE directive_verifiers SET last_run_at = NOW(), last_result = $2, updated_at = NOW() + WHERE id = $1 + RETURNING * "#, ) - .bind(chain_contract_id) - .fetch_optional(pool) - .await?; + .bind(verifier_id) + .bind(result) + .fetch_one(pool) + .await +} - Ok(result.map(|(n,)| n).unwrap_or(1)) +// ============================================================================= +// Directive Approval Operations +// ============================================================================= + +/// Create an approval request. +pub async fn create_approval_request( + pool: &PgPool, + directive_id: Uuid, + step_id: Option<Uuid>, + approval_type: &str, + description: &str, + context: Option<serde_json::Value>, + urgency: &str, + expires_at: Option<chrono::DateTime<Utc>>, +) -> Result<DirectiveApproval, sqlx::Error> { + sqlx::query_as::<_, DirectiveApproval>( + r#" + INSERT INTO directive_approvals ( + directive_id, step_id, approval_type, description, context, urgency, expires_at + ) + VALUES ($1, $2, $3, $4, $5, $6, $7) + RETURNING * + "#, + ) + .bind(directive_id) + .bind(step_id) + .bind(approval_type) + .bind(description) + .bind(context) + .bind(urgency) + .bind(expires_at) + .fetch_one(pool) + .await } -/// Update chain contract evaluation status. -pub async fn update_chain_contract_evaluation_status( +/// Resolve an approval request. +pub async fn resolve_approval( pool: &PgPool, - chain_contract_id: Uuid, + approval_id: Uuid, status: &str, - evaluation_id: Option<Uuid>, - rework_feedback: Option<&str>, -) -> Result<ChainContract, sqlx::Error> { - sqlx::query_as::<_, ChainContract>( - r#" - UPDATE chain_contracts SET - evaluation_status = $2, - last_evaluation_id = COALESCE($3, last_evaluation_id), - rework_feedback = COALESCE($4, rework_feedback), - evaluation_retry_count = CASE - WHEN $2 = 'rework' THEN evaluation_retry_count + 1 - ELSE evaluation_retry_count - END, - rework_started_at = CASE - WHEN $2 = 'rework' THEN NOW() - ELSE rework_started_at - END + response: Option<&str>, + responded_by: Uuid, +) -> Result<DirectiveApproval, sqlx::Error> { + sqlx::query_as::<_, DirectiveApproval>( + r#" + UPDATE directive_approvals SET + status = $2, + response = $3, + responded_by = $4, + responded_at = NOW() WHERE id = $1 RETURNING * "#, ) - .bind(chain_contract_id) + .bind(approval_id) .bind(status) - .bind(evaluation_id) - .bind(rework_feedback) + .bind(response) + .bind(responded_by) .fetch_one(pool) .await } -/// Mark a chain contract's original completion time (before rework). -pub async fn mark_chain_contract_original_completion( +/// List pending approvals for a directive. +pub async fn list_pending_approvals( pool: &PgPool, - chain_contract_id: Uuid, -) -> Result<(), sqlx::Error> { - sqlx::query( + directive_id: Uuid, +) -> Result<Vec<DirectiveApproval>, sqlx::Error> { + sqlx::query_as::<_, DirectiveApproval>( r#" - UPDATE chain_contracts SET - original_completion_at = COALESCE(original_completion_at, NOW()) - WHERE id = $1 + SELECT * FROM directive_approvals + WHERE directive_id = $1 AND status = 'pending' + ORDER BY + CASE urgency + WHEN 'critical' THEN 1 + WHEN 'high' THEN 2 + WHEN 'normal' THEN 3 + ELSE 4 + END, + created_at "#, ) - .bind(chain_contract_id) - .execute(pool) - .await?; - Ok(()) + .bind(directive_id) + .fetch_all(pool) + .await } -/// Get chain contract by contract ID. -pub async fn get_chain_contract_by_contract_id( +/// Get step by contract ID. +pub async fn get_step_by_contract_id( pool: &PgPool, contract_id: Uuid, -) -> Result<Option<ChainContract>, sqlx::Error> { - sqlx::query_as::<_, ChainContract>( - r#" - SELECT * - FROM chain_contracts - WHERE contract_id = $1 - "#, +) -> Result<Option<ChainStep>, sqlx::Error> { + sqlx::query_as::<_, ChainStep>( + "SELECT * FROM chain_steps WHERE contract_id = $1" ) .bind(contract_id) .fetch_optional(pool) @@ -6682,103 +6034,9 @@ pub async fn get_chain_contract_by_contract_id( } // ============================================================================= -// Init Chain (Directive-Driven Chain Creation) +// Helper Functions // ============================================================================= -/// Initialize a directive-driven chain. -/// Creates a directive contract and an empty chain linked to it. -pub async fn init_chain_for_owner( - pool: &PgPool, - owner_id: Uuid, - req: InitChainRequest, -) -> Result<InitChainResponse, sqlx::Error> { - // Create the directive contract - // Note: "directive" contract type uses the "specification" phases by default - let contract_req = CreateContractRequest { - name: format!("Directive: {}", truncate_string(&req.goal, 50)), - description: Some(req.goal.clone()), - contract_type: Some("specification".to_string()), // Directive uses spec workflow - template_id: None, - initial_phase: Some("research".to_string()), - phase_guard: Some(req.phase_guard), - autonomous_loop: Some(false), - local_only: Some(false), - auto_merge_local: Some(false), - }; - - let contract = create_contract_for_owner(pool, owner_id, contract_req).await?; - - // Mark it as a chain directive - sqlx::query("UPDATE contracts SET is_chain_directive = true WHERE id = $1") - .bind(contract.id) - .execute(pool) - .await?; - - // Build repositories list from request - let repositories = match (req.repository_url.as_ref(), req.local_path.as_ref()) { - (Some(url), _) => Some(vec![AddChainRepositoryRequest { - name: "Primary".to_string(), - repository_url: Some(url.clone()), - local_path: None, - source_type: "remote".to_string(), - is_primary: true, - }]), - (None, Some(path)) => Some(vec![AddChainRepositoryRequest { - name: "Primary".to_string(), - repository_url: None, - local_path: Some(path.clone()), - source_type: "local".to_string(), - is_primary: true, - }]), - (None, None) => None, - }; - - // Create the chain with directive contract reference - let chain_req = CreateChainRequest { - name: truncate_string(&req.goal, 100), - description: Some(req.goal), - repositories, - loop_enabled: Some(false), - loop_max_iterations: None, - loop_progress_check: None, - contracts: None, - }; - - let chain = create_chain_for_owner(pool, owner_id, chain_req).await?; - - // Link directive contract to chain - sqlx::query( - r#" - UPDATE chains SET directive_contract_id = $2 WHERE id = $1; - UPDATE contracts SET spawned_chain_id = $1 WHERE id = $2; - "#, - ) - .bind(chain.id) - .bind(contract.id) - .execute(pool) - .await?; - - // Create empty directive document - create_chain_directive( - pool, - chain.id, - CreateChainDirectiveRequest { - requirements: Some(vec![]), - acceptance_criteria: Some(vec![]), - constraints: Some(vec![]), - external_dependencies: Some(vec![]), - source_type: Some("llm_generated".to_string()), - }, - ) - .await?; - - Ok(InitChainResponse { - chain_id: chain.id, - directive_contract_id: contract.id, - supervisor_task_id: contract.supervisor_task_id, - }) -} - /// Helper to truncate string to max length fn truncate_string(s: &str, max_len: usize) -> String { if s.len() <= max_len { diff --git a/makima/src/lib.rs b/makima/src/lib.rs index 8d3db58..3bc460b 100644 --- a/makima/src/lib.rs +++ b/makima/src/lib.rs @@ -3,5 +3,6 @@ pub mod daemon; pub mod db; pub mod listen; pub mod llm; +pub mod orchestration; pub mod server; pub mod tts; diff --git a/makima/src/llm/contract_evaluator.rs b/makima/src/llm/contract_evaluator.rs index fcc4826..e63bbfa 100644 --- a/makima/src/llm/contract_evaluator.rs +++ b/makima/src/llm/contract_evaluator.rs @@ -1,25 +1,19 @@ //! Contract Evaluator - LLM-based evaluation of completed contracts against directive. //! -//! This module provides functionality for: -//! - Gathering deliverables, files, and task outputs from completed contracts -//! - Building evaluation prompts using directive and acceptance criteria -//! - Calling LLM to evaluate work against requirements -//! - Parsing evaluation responses +//! This module will be reimplemented as part of the directive verification engine. +//! See the orchestration module for the new evaluation system. +//! +//! The new evaluation system will provide: +//! - Tiered verification (programmatic verifiers first, then LLM evaluation) +//! - Composite confidence scoring (weighted combination of results) +//! - Pluggable verifier interface (test runner, linter, build, type checker) +//! - Proper integration with the directive chain steps use serde::{Deserialize, Serialize}; use sqlx::PgPool; use uuid::Uuid; -use crate::db::{ - models::{ - ChainContract, ChainDirective, Contract, ContractEvaluation, CreateContractEvaluationRequest, - DirectiveAcceptanceCriterion, DirectiveRequirement, EvaluationCriterionResult, - }, - repository, -}; - -use super::claude::{ClaudeClient, ClaudeModel, Message, MessageContent}; -use super::tools::Tool; +// use crate::db::models::{Contract, DirectiveAcceptanceCriterion, DirectiveRequirement}; /// Result of contract evaluation #[derive(Debug, Clone, Serialize, Deserialize)] @@ -30,526 +24,74 @@ pub struct ContractEvaluationResult { /// Overall score from 0.0 to 1.0 pub overall_score: f64, /// Results for each acceptance criterion - pub criteria_results: Vec<EvaluationCriterionResult>, + pub criteria_results: Vec<EvaluationCriterionResultLegacy>, /// Summary feedback from the evaluator pub summary_feedback: String, /// Instructions for rework if failed pub rework_instructions: Option<String>, } -/// Context gathered for evaluation -#[derive(Debug, Clone)] -pub struct EvaluationContext { - /// The contract being evaluated - pub contract: Contract, - /// The chain contract record - pub chain_contract: ChainContract, - /// The directive document - pub directive: ChainDirective, - /// Files associated with the contract - pub files: Vec<FileContent>, - /// Task outputs from the contract - pub task_outputs: Vec<TaskOutput>, - /// Deliverables marked as complete - pub deliverables: Vec<DeliverableInfo>, - /// Acceptance criteria specific to this contract - pub acceptance_criteria: Vec<DirectiveAcceptanceCriterion>, - /// Requirements mapped to this contract - pub requirements: Vec<DirectiveRequirement>, +/// Per-criterion evaluation result (legacy - kept for compatibility) +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct EvaluationCriterionResultLegacy { + pub criterion_id: String, + pub criterion_text: String, + pub passed: bool, + /// Score (0.0-1.0) + pub score: f64, + pub feedback: String, + /// Evidence supporting the evaluation + pub evidence: Vec<String>, } -/// File content for evaluation -#[derive(Debug, Clone, Serialize)] +/// File content for evaluation context +#[derive(Debug, Clone)] pub struct FileContent { pub path: String, - pub description: Option<String>, pub content: String, - pub is_deliverable: bool, } -/// Task output for evaluation -#[derive(Debug, Clone, Serialize)] -pub struct TaskOutput { - pub task_name: String, - pub output_summary: String, - pub exit_code: Option<i32>, -} - -/// Deliverable info for evaluation -#[derive(Debug, Clone, Serialize)] -pub struct DeliverableInfo { - pub name: String, - pub status: String, - pub file_path: Option<String>, -} - -/// Error types for evaluation -#[derive(Debug, thiserror::Error)] -pub enum EvaluationError { - #[error("Database error: {0}")] - Database(#[from] sqlx::Error), - - #[error("Contract not found: {0}")] - ContractNotFound(Uuid), - - #[error("Chain contract not found for contract: {0}")] - ChainContractNotFound(Uuid), - - #[error("Directive not found for chain: {0}")] - DirectiveNotFound(Uuid), - - #[error("LLM evaluation failed: {0}")] - LlmError(String), - - #[error("Failed to parse evaluation response: {0}")] - ParseError(String), -} - -/// Contract evaluator for directive-driven evaluation +/// Contract evaluator for LLM-based assessment. +/// +/// NOTE: This is a stub implementation. The full evaluation system will be +/// implemented as part of the orchestration/verifier module. pub struct ContractEvaluator { - pool: PgPool, - claude_client: ClaudeClient, - model: ClaudeModel, - /// Minimum score required to pass (default 0.8) - pass_threshold: f64, + _pool: PgPool, } impl ContractEvaluator { - /// Create a new evaluator - pub fn new(pool: PgPool, claude_client: ClaudeClient) -> Self { - Self { - pool, - claude_client, - model: ClaudeModel::Sonnet, - pass_threshold: 0.8, - } - } - - /// Set the LLM model to use for evaluation - pub fn with_model(mut self, model: ClaudeModel) -> Self { - self.model = model; - self - } - - /// Set the pass threshold - pub fn with_pass_threshold(mut self, threshold: f64) -> Self { - self.pass_threshold = threshold; - self + /// Create a new contract evaluator. + pub fn new(pool: PgPool) -> Self { + Self { _pool: pool } } - /// Evaluate a completed contract against the directive + /// Evaluate a contract - stub implementation. + /// + /// This will be reimplemented in the orchestration module with: + /// - Programmatic verification (tests, lint, build) + /// - LLM evaluation + /// - Composite scoring pub async fn evaluate_contract( &self, - contract_id: Uuid, - owner_id: Uuid, - ) -> Result<ContractEvaluationResult, EvaluationError> { - // Gather evaluation context - let context = self.gather_context(contract_id, owner_id).await?; - - // Build evaluation prompt - let prompt = self.build_evaluation_prompt(&context); - - // Call LLM for evaluation - let response = self.call_llm_for_evaluation(&prompt).await?; - - // Parse the response - let result = self.parse_evaluation_response(&response, &context)?; - - Ok(result) - } - - /// Gather all context needed for evaluation - async fn gather_context( - &self, - contract_id: Uuid, - owner_id: Uuid, - ) -> Result<EvaluationContext, EvaluationError> { - // Get contract - let contract = repository::get_contract_for_owner(&self.pool, contract_id, owner_id) - .await? - .ok_or(EvaluationError::ContractNotFound(contract_id))?; - - // Get chain contract - let chain_contract = repository::get_chain_contract_by_contract_id(&self.pool, contract_id) - .await? - .ok_or(EvaluationError::ChainContractNotFound(contract_id))?; - - // Get directive - let directive = repository::get_chain_directive(&self.pool, chain_contract.chain_id) - .await? - .ok_or(EvaluationError::DirectiveNotFound(chain_contract.chain_id))?; - - // Get files directly from repository - let contract_files = repository::list_files_in_contract(&self.pool, contract_id, owner_id) - .await - .unwrap_or_default(); - - // Get tasks directly from repository - let contract_tasks = repository::list_tasks_in_contract(&self.pool, contract_id, owner_id) - .await - .unwrap_or_default(); - - // Build file contents from FileSummary - // Note: FileSummary doesn't have content, so we use name and description - let files: Vec<FileContent> = contract_files.iter().map(|f| { - FileContent { - path: f.repo_file_path.clone().unwrap_or_else(|| f.name.clone()), - description: f.description.clone(), - content: format!("[File: {} - content not loaded in summary view]", f.name), - is_deliverable: false, // FileSummary doesn't track deliverable status - } - }).collect(); - - // Build task outputs from TaskSummary - let task_outputs: Vec<TaskOutput> = contract_tasks.iter().map(|t| { - TaskOutput { - task_name: t.name.clone(), - output_summary: t.progress_summary.clone().unwrap_or_else(|| format!("Status: {}", t.status)), - exit_code: None, - } - }).collect(); - - // Build deliverables info from files marked as deliverables - // Since FileSummary doesn't have deliverable info, we treat all files as potential deliverables - let deliverables: Vec<DeliverableInfo> = contract_files.iter() - .map(|f| DeliverableInfo { - name: f.name.clone(), - status: "complete".to_string(), - file_path: f.repo_file_path.clone(), - }) - .collect(); - - // Parse requirements and acceptance criteria from directive - let requirements: Vec<DirectiveRequirement> = - serde_json::from_value(directive.requirements.clone()).unwrap_or_default(); - - let all_criteria: Vec<DirectiveAcceptanceCriterion> = - serde_json::from_value(directive.acceptance_criteria.clone()).unwrap_or_default(); - - // Get contract definition to find mapped requirements - // For now, use all acceptance criteria - let acceptance_criteria = all_criteria; - - Ok(EvaluationContext { - contract, - chain_contract, - directive, - files, - task_outputs, - deliverables, - acceptance_criteria, - requirements, - }) + _contract_id: Uuid, + ) -> Result<ContractEvaluationResult, ContractEvaluatorError> { + // TODO: Implement using the new directive evaluation system + Err(ContractEvaluatorError::NotImplemented( + "Contract evaluator will be reimplemented with directive system".to_string(), + )) } - - /// Build the evaluation prompt - fn build_evaluation_prompt(&self, context: &EvaluationContext) -> String { - let mut prompt = String::new(); - - prompt.push_str("# Contract Completion Evaluation\n\n"); - prompt.push_str("You are evaluating whether a contract has been completed successfully against its requirements.\n\n"); - - // Contract info - prompt.push_str("## Contract Information\n\n"); - prompt.push_str(&format!("**Name:** {}\n", context.contract.name)); - if let Some(ref desc) = context.contract.description { - prompt.push_str(&format!("**Description:** {}\n", desc)); - } - prompt.push_str(&format!("**Type:** {}\n", context.contract.contract_type)); - prompt.push_str(&format!("**Phase:** {}\n", context.contract.phase)); - prompt.push_str("\n"); - - // Requirements - if !context.requirements.is_empty() { - prompt.push_str("## Requirements\n\n"); - for req in &context.requirements { - prompt.push_str(&format!("- **{}** ({}): {}\n", req.id, req.priority, req.title)); - if !req.description.is_empty() { - prompt.push_str(&format!(" {}\n", req.description)); - } - } - prompt.push_str("\n"); - } - - // Acceptance criteria - if !context.acceptance_criteria.is_empty() { - prompt.push_str("## Acceptance Criteria\n\n"); - for (i, criterion) in context.acceptance_criteria.iter().enumerate() { - prompt.push_str(&format!("{}. **{}**\n", i + 1, criterion.description)); - prompt.push_str(&format!(" - Testable: {}\n", criterion.testable)); - if !criterion.requirement_ids.is_empty() { - prompt.push_str(&format!(" - Covers: {}\n", criterion.requirement_ids.join(", "))); - } - } - prompt.push_str("\n"); - } - - // Deliverables - if !context.deliverables.is_empty() { - prompt.push_str("## Deliverables\n\n"); - for d in &context.deliverables { - prompt.push_str(&format!("- {} ({})\n", d.name, d.status)); - } - prompt.push_str("\n"); - } - - // Files - if !context.files.is_empty() { - prompt.push_str("## Files Created/Modified\n\n"); - for file in &context.files { - prompt.push_str(&format!("### {}", file.path)); - if file.is_deliverable { - prompt.push_str(" [DELIVERABLE]"); - } - prompt.push_str("\n"); - if let Some(ref desc) = file.description { - prompt.push_str(&format!("*{}*\n", desc)); - } - // Truncate content if too long - let content = if file.content.len() > 5000 { - format!("{}...\n[Content truncated - {} chars total]", - &file.content[..5000], file.content.len()) - } else { - file.content.clone() - }; - prompt.push_str("```\n"); - prompt.push_str(&content); - prompt.push_str("\n```\n\n"); - } - } - - // Task outputs - if !context.task_outputs.is_empty() { - prompt.push_str("## Task Outputs\n\n"); - for task in &context.task_outputs { - prompt.push_str(&format!("### {}\n", task.task_name)); - prompt.push_str(&format!("{}\n\n", task.output_summary)); - } - } - - // Evaluation instructions - prompt.push_str("## Evaluation Instructions\n\n"); - prompt.push_str("Please evaluate the completed work against the requirements and acceptance criteria.\n\n"); - prompt.push_str("For each acceptance criterion, determine if it has been met and provide a brief explanation.\n\n"); - prompt.push_str("Respond with a JSON object in the following format:\n\n"); - prompt.push_str("```json\n"); - prompt.push_str(r#"{ - "passed": true/false, - "overallScore": 0.0-1.0, - "criteriaResults": [ - { - "criterionId": "criterion identifier or index", - "met": true/false, - "score": 0.0-1.0, - "feedback": "explanation of why criterion was/wasn't met" - } - ], - "summaryFeedback": "overall summary of the evaluation", - "reworkInstructions": "if failed, specific instructions for what needs to be fixed (null if passed)" -} -"#); - prompt.push_str("```\n\n"); - prompt.push_str(&format!("The pass threshold is {}. ", self.pass_threshold)); - prompt.push_str("A contract passes if the overall score is >= the threshold AND all critical criteria are met.\n"); - - prompt - } - - /// Call LLM for evaluation - async fn call_llm_for_evaluation(&self, prompt: &str) -> Result<String, EvaluationError> { - let messages = vec![Message { - role: "user".to_string(), - content: MessageContent::Text(prompt.to_string()), - }]; - - // Use chat_with_tools with empty tools array for simple chat - let empty_tools: Vec<Tool> = vec![]; - let result = self - .claude_client - .chat_with_tools(messages, &empty_tools) - .await - .map_err(|e| EvaluationError::LlmError(e.to_string()))?; - - // ChatResult.content is already an Option<String> - let text = result.content.unwrap_or_default(); - - Ok(text) - } - - /// Parse the LLM response into an evaluation result - fn parse_evaluation_response( - &self, - response: &str, - context: &EvaluationContext, - ) -> Result<ContractEvaluationResult, EvaluationError> { - // Extract JSON from response (may be wrapped in markdown code blocks) - let json_str = extract_json_from_response(response)?; - - // Parse the JSON - let parsed: EvaluationResponseJson = serde_json::from_str(&json_str) - .map_err(|e| EvaluationError::ParseError(format!("JSON parse error: {}", e)))?; - - // Convert to our result type - let criteria_results: Vec<EvaluationCriterionResult> = parsed - .criteria_results - .into_iter() - .map(|cr| EvaluationCriterionResult { - criterion_id: cr.criterion_id.clone(), - criterion_text: cr.criterion_id, // Use ID as text if not provided - passed: cr.passed, - score: cr.score, - feedback: cr.feedback, - evidence: vec![], - }) - .collect(); - - // Determine pass/fail based on threshold and results - let passed = parsed.passed && parsed.overall_score >= self.pass_threshold; - - Ok(ContractEvaluationResult { - passed, - overall_score: parsed.overall_score, - criteria_results, - summary_feedback: parsed.summary_feedback, - rework_instructions: if passed { None } else { parsed.rework_instructions }, - }) - } - - /// Save evaluation result to database - pub async fn save_evaluation( - &self, - contract_id: Uuid, - chain_id: Uuid, - chain_contract_id: Uuid, - result: &ContractEvaluationResult, - ) -> Result<ContractEvaluation, EvaluationError> { - let req = CreateContractEvaluationRequest { - contract_id, - chain_id: Some(chain_id), - chain_contract_id: Some(chain_contract_id), - evaluator_model: Some(format!("{:?}", self.model)), - passed: result.passed, - overall_score: Some(result.overall_score), - criteria_results: result.criteria_results.clone(), - summary_feedback: result.summary_feedback.clone(), - rework_instructions: result.rework_instructions.clone(), - }; - - let evaluation = repository::create_contract_evaluation(&self.pool, req).await?; - - // Update chain contract status - let status = if result.passed { "passed" } else { "failed" }; - repository::update_chain_contract_evaluation_status( - &self.pool, - chain_contract_id, - status, - Some(evaluation.id), - result.rework_instructions.as_deref(), - ) - .await?; - - Ok(evaluation) - } -} - -/// JSON structure for parsing LLM response -#[derive(Debug, Deserialize)] -#[serde(rename_all = "camelCase")] -struct EvaluationResponseJson { - passed: bool, - overall_score: f64, - criteria_results: Vec<CriterionResultJson>, - summary_feedback: String, - rework_instructions: Option<String>, -} - -#[derive(Debug, Deserialize)] -#[serde(rename_all = "camelCase")] -struct CriterionResultJson { - criterion_id: String, - #[serde(alias = "met")] - passed: bool, - #[serde(default)] - score: f64, - feedback: String, -} - -/// Extract JSON from a response that may contain markdown code blocks -fn extract_json_from_response(response: &str) -> Result<String, EvaluationError> { - // Try to find JSON in code blocks first - if let Some(start) = response.find("```json") { - let json_start = start + 7; - if let Some(end) = response[json_start..].find("```") { - return Ok(response[json_start..json_start + end].trim().to_string()); - } - } - - // Try plain code blocks - if let Some(start) = response.find("```") { - let json_start = start + 3; - // Skip any language identifier on the same line - let actual_start = response[json_start..] - .find('\n') - .map(|i| json_start + i + 1) - .unwrap_or(json_start); - if let Some(end) = response[actual_start..].find("```") { - return Ok(response[actual_start..actual_start + end].trim().to_string()); - } - } - - // Try to find raw JSON (starts with {) - if let Some(start) = response.find('{') { - // Find matching closing brace - let mut depth = 0; - let mut end = start; - for (i, c) in response[start..].char_indices() { - match c { - '{' => depth += 1, - '}' => { - depth -= 1; - if depth == 0 { - end = start + i + 1; - break; - } - } - _ => {} - } - } - if end > start { - return Ok(response[start..end].to_string()); - } - } - - Err(EvaluationError::ParseError( - "Could not find JSON in response".to_string(), - )) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_extract_json_from_code_block() { - let response = r#"Here is the evaluation: - -```json -{ - "passed": true, - "overallScore": 0.85 } -``` -Done."#; +/// Error types for contract evaluation. +#[derive(Debug, thiserror::Error)] +pub enum ContractEvaluatorError { + #[error("Database error: {0}")] + Database(#[from] sqlx::Error), - let json = extract_json_from_response(response).unwrap(); - assert!(json.contains("\"passed\": true")); - } + #[error("LLM error: {0}")] + Llm(String), - #[test] - fn test_extract_json_raw() { - let response = r#"The result is {"passed": false, "overallScore": 0.5}"#; - let json = extract_json_from_response(response).unwrap(); - assert!(json.contains("\"passed\": false")); - } + #[error("Not implemented: {0}")] + NotImplemented(String), } diff --git a/makima/src/llm/mod.rs b/makima/src/llm/mod.rs index 702e1fd..6c9965c 100644 --- a/makima/src/llm/mod.rs +++ b/makima/src/llm/mod.rs @@ -46,7 +46,7 @@ pub use transcript_analyzer::{ calculate_speaker_stats, build_analysis_prompt, parse_analysis_response, }; pub use contract_evaluator::{ - ContractEvaluator, ContractEvaluationResult, EvaluationContext, EvaluationError, + ContractEvaluator, ContractEvaluationResult, ContractEvaluatorError, }; /// Available LLM providers and models diff --git a/makima/src/llm/task_output.rs b/makima/src/llm/task_output.rs index c5d709e..c7f6990 100644 --- a/makima/src/llm/task_output.rs +++ b/makima/src/llm/task_output.rs @@ -126,7 +126,7 @@ pub fn parse_tasks_from_breakdown(content: &str) -> TaskParseResult { let heading_pattern = Regex::new(r"^##\s+(?:Phase\s*\d*:?\s*)?(.+)$").unwrap(); // Patterns for dependencies (inline) - let depends_pattern = Regex::new(r"(?i)(?:depends on|after|requires):?\s*(.+)").unwrap(); + let depends_pattern = Regex::new(r"(?i)\(?\s*(?:depends on|after|requires):?\s*([^)]+)\)?").unwrap(); for line in content.lines() { let trimmed = line.trim(); @@ -226,7 +226,7 @@ pub fn parse_tasks_from_breakdown(content: &str) -> TaskParseResult { } } -/// Check if text looks like a task (has action verbs) +/// Check if text looks like a task (has action verbs at word boundaries) fn looks_like_task(text: &str) -> bool { let lower = text.to_lowercase(); let action_verbs = [ @@ -237,7 +237,27 @@ fn looks_like_task(text: &str) -> bool { "disable", "install", "initialize", "define", "extend", "extract", ]; - action_verbs.iter().any(|verb| lower.starts_with(verb) || lower.contains(&format!(" {}", verb))) + // Check if text starts with an action verb (followed by space or end) + for verb in &action_verbs { + if lower.starts_with(verb) { + // Check for word boundary after verb + let after = &lower[verb.len()..]; + if after.is_empty() || after.starts_with(' ') || after.starts_with('_') { + return true; + } + } + // Check if verb appears after space with word boundary + let pattern = format!(" {} ", verb); + let pattern_end = format!(" {}", verb); + if lower.contains(&pattern) { + return true; + } + // Check if verb is at the end of string after a space + if lower.ends_with(&pattern_end) && lower.len() > pattern_end.len() { + return true; + } + } + false } /// Analyze a completed task's output to suggest next actions diff --git a/makima/src/orchestration/engine.rs b/makima/src/orchestration/engine.rs new file mode 100644 index 0000000..5bbb99f --- /dev/null +++ b/makima/src/orchestration/engine.rs @@ -0,0 +1,976 @@ +//! Directive orchestration engine. +//! +//! Manages the lifecycle of directives: +//! - Starts directives and generates initial chains +//! - Monitors step execution and triggers evaluations +//! - Handles rework, escalation, and chain regeneration +//! - Enforces circuit breakers (cost, time, rework limits) + +use std::collections::HashMap; + +use sqlx::PgPool; +use thiserror::Error; +use tokio::sync::broadcast; +use uuid::Uuid; + +use crate::db::models::{AddStepRequest, ChainStep, Directive, DirectiveEvent, UpdateStepRequest}; +use crate::db::repository::{self, RepositoryError}; + +use super::planner::{ChainPlanner, GeneratedChain, PlannerError}; +use super::verifier::{ + auto_detect_verifiers, CompositeEvaluator, ConfidenceLevel, EvaluationResult, + VerificationContext, +}; + +/// Error type for engine operations. +#[derive(Error, Debug)] +pub enum EngineError { + #[error("Database error: {0}")] + Database(#[from] sqlx::Error), + + #[error("Repository error: {0}")] + Repository(#[from] RepositoryError), + + #[error("Planner error: {0}")] + Planner(#[from] PlannerError), + + #[error("Directive not found: {0}")] + DirectiveNotFound(Uuid), + + #[error("Chain not found for directive: {0}")] + ChainNotFound(Uuid), + + #[error("Step not found: {0}")] + StepNotFound(Uuid), + + #[error("Invalid state transition: {from} -> {to}")] + InvalidStateTransition { from: String, to: String }, + + #[error("Circuit breaker triggered: {0}")] + CircuitBreaker(String), + + #[error("Directive is paused")] + DirectivePaused, + + #[error("Contract creation failed: {0}")] + ContractCreation(String), + + #[error("LLM error: {0}")] + LlmError(String), +} + +/// Event emitted by the engine for UI updates. +#[derive(Debug, Clone)] +pub enum EngineEvent { + /// Directive status changed + DirectiveStatusChanged { + directive_id: Uuid, + old_status: String, + new_status: String, + }, + /// Step status changed + StepStatusChanged { + directive_id: Uuid, + step_id: Uuid, + old_status: String, + new_status: String, + }, + /// Evaluation completed + EvaluationCompleted { + directive_id: Uuid, + step_id: Uuid, + passed: bool, + confidence_level: ConfidenceLevel, + }, + /// Approval required + ApprovalRequired { + directive_id: Uuid, + approval_id: Uuid, + approval_type: String, + }, + /// Chain regenerated + ChainRegenerated { + directive_id: Uuid, + old_chain_id: Uuid, + new_chain_id: Uuid, + }, +} + +/// Main orchestration engine for directives. +pub struct DirectiveEngine { + pool: PgPool, + planner: ChainPlanner, + event_tx: Option<broadcast::Sender<EngineEvent>>, +} + +impl DirectiveEngine { + /// Create a new directive engine. + pub fn new(pool: PgPool) -> Self { + Self { + pool, + planner: ChainPlanner::new(), + event_tx: None, + } + } + + /// Set the event broadcast channel for UI updates. + pub fn with_event_channel(mut self, tx: broadcast::Sender<EngineEvent>) -> Self { + self.event_tx = Some(tx); + self + } + + /// Emit an event if channel is configured. + fn emit_event(&self, event: EngineEvent) { + if let Some(tx) = &self.event_tx { + let _ = tx.send(event); + } + } + + // ======================================================================== + // Directive Lifecycle + // ======================================================================== + + /// Start a directive: generate chain and begin execution. + pub async fn start_directive(&self, directive_id: Uuid) -> Result<(), EngineError> { + let directive = repository::get_directive(&self.pool, directive_id) + .await? + .ok_or(EngineError::DirectiveNotFound(directive_id))?; + + // Validate current state + if directive.status != "draft" && directive.status != "paused" { + return Err(EngineError::InvalidStateTransition { + from: directive.status, + to: "planning".to_string(), + }); + } + + // Update status to planning + repository::update_directive_status(&self.pool, directive_id, "planning").await?; + self.emit_directive_event( + directive_id, + "status_changed", + "info", + serde_json::json!({"old_status": directive.status, "new_status": "planning"}), + "system", + ) + .await?; + + // Generate chain (placeholder - actual LLM call would go here) + let chain = self.generate_initial_chain(&directive).await?; + + // Create chain in database + let db_chain = repository::create_directive_chain( + &self.pool, + directive_id, + &chain.name, + Some(&chain.description), + None, // rationale + None, // planning_model + ) + .await?; + + // Create steps + self.create_steps_from_chain(&db_chain.id, &chain).await?; + + // Update directive to active + repository::update_directive_status(&self.pool, directive_id, "active").await?; + self.emit_event(EngineEvent::DirectiveStatusChanged { + directive_id, + old_status: "planning".to_string(), + new_status: "active".to_string(), + }); + + // Start ready steps + self.advance_chain(directive_id).await?; + + Ok(()) + } + + /// Pause a directive. + pub async fn pause_directive(&self, directive_id: Uuid) -> Result<(), EngineError> { + let directive = repository::get_directive(&self.pool, directive_id) + .await? + .ok_or(EngineError::DirectiveNotFound(directive_id))?; + + if directive.status != "active" { + return Err(EngineError::InvalidStateTransition { + from: directive.status, + to: "paused".to_string(), + }); + } + + repository::update_directive_status(&self.pool, directive_id, "paused").await?; + self.emit_event(EngineEvent::DirectiveStatusChanged { + directive_id, + old_status: "active".to_string(), + new_status: "paused".to_string(), + }); + + Ok(()) + } + + /// Resume a paused directive. + pub async fn resume_directive(&self, directive_id: Uuid) -> Result<(), EngineError> { + let directive = repository::get_directive(&self.pool, directive_id) + .await? + .ok_or(EngineError::DirectiveNotFound(directive_id))?; + + if directive.status != "paused" { + return Err(EngineError::InvalidStateTransition { + from: directive.status, + to: "active".to_string(), + }); + } + + repository::update_directive_status(&self.pool, directive_id, "active").await?; + self.emit_event(EngineEvent::DirectiveStatusChanged { + directive_id, + old_status: "paused".to_string(), + new_status: "active".to_string(), + }); + + // Continue execution + self.advance_chain(directive_id).await?; + + Ok(()) + } + + /// Stop a directive (cannot be resumed). + pub async fn stop_directive(&self, directive_id: Uuid) -> Result<(), EngineError> { + let directive = repository::get_directive(&self.pool, directive_id) + .await? + .ok_or(EngineError::DirectiveNotFound(directive_id))?; + + if directive.status == "completed" || directive.status == "failed" { + return Err(EngineError::InvalidStateTransition { + from: directive.status, + to: "failed".to_string(), + }); + } + + repository::update_directive_status(&self.pool, directive_id, "failed").await?; + self.emit_event(EngineEvent::DirectiveStatusChanged { + directive_id, + old_status: directive.status, + new_status: "failed".to_string(), + }); + + Ok(()) + } + + // ======================================================================== + // Chain Management + // ======================================================================== + + /// Generate initial chain from directive. + async fn generate_initial_chain( + &self, + directive: &Directive, + ) -> Result<GeneratedChain, EngineError> { + // Build planning prompt + let _prompt = self.planner.build_planning_prompt(directive); + + // TODO: Call LLM to generate chain + // For now, return a simple placeholder chain + let chain = GeneratedChain { + name: format!("{}-chain", directive.title.to_lowercase().replace(' ', "-")), + description: format!("Execution plan for: {}", directive.goal), + steps: vec![ + super::planner::GeneratedStep { + name: "research".to_string(), + step_type: "research".to_string(), + description: "Research and understand the requirements".to_string(), + depends_on: vec![], + requirement_ids: vec![], + contract_template: None, + }, + super::planner::GeneratedStep { + name: "implement".to_string(), + step_type: "implement".to_string(), + description: "Implement the solution".to_string(), + depends_on: vec!["research".to_string()], + requirement_ids: vec![], + contract_template: None, + }, + super::planner::GeneratedStep { + name: "test".to_string(), + step_type: "test".to_string(), + description: "Test and verify the implementation".to_string(), + depends_on: vec!["implement".to_string()], + requirement_ids: vec![], + contract_template: None, + }, + ], + }; + + // Validate the chain + self.planner.validate_chain(&chain)?; + + Ok(chain) + } + + /// Create database steps from a generated chain. + async fn create_steps_from_chain( + &self, + chain_id: &Uuid, + chain: &GeneratedChain, + ) -> Result<(), EngineError> { + // First pass: create all steps and build name-to-id map + let mut step_id_map: HashMap<String, Uuid> = HashMap::new(); + + // Get editor positions + let positions = self.planner.compute_editor_positions(chain); + + for step in &chain.steps { + let (editor_x, editor_y) = positions + .get(&step.name) + .copied() + .unwrap_or((100.0, 100.0)); + + let task_plan = step + .contract_template + .as_ref() + .and_then(|t| t.tasks.first()) + .map(|t| t.plan.clone()) + .or_else(|| Some(step.description.clone())); + + let request = AddStepRequest { + name: step.name.clone(), + description: Some(step.description.clone()), + step_type: Some(step.step_type.clone()), + contract_type: step.contract_template.as_ref().map(|t| t.contract_type.clone()), + initial_phase: Some("plan".to_string()), + task_plan, + phases: step.contract_template.as_ref().map(|t| t.phases.clone()), + depends_on: None, // Will update in second pass + parallel_group: None, + requirement_ids: Some(step.requirement_ids.clone()), + acceptance_criteria_ids: None, + verifier_config: None, + editor_x: Some(editor_x), + editor_y: Some(editor_y), + }; + + let db_step = repository::create_chain_step(&self.pool, *chain_id, request).await?; + step_id_map.insert(step.name.clone(), db_step.id); + } + + // Second pass: update dependencies + for step in &chain.steps { + if step.depends_on.is_empty() { + continue; + } + + let step_id = step_id_map.get(&step.name).unwrap(); + let dep_ids: Vec<Uuid> = step + .depends_on + .iter() + .filter_map(|name| step_id_map.get(name)) + .copied() + .collect(); + + // Update step with proper dependencies + let update = UpdateStepRequest { + name: None, + description: None, + task_plan: None, + depends_on: Some(dep_ids), + requirement_ids: None, + acceptance_criteria_ids: None, + verifier_config: None, + editor_x: None, + editor_y: None, + }; + + repository::update_chain_step(&self.pool, *step_id, update).await?; + } + + Ok(()) + } + + /// Regenerate chain while preserving completed steps. + pub async fn regenerate_chain( + &self, + directive_id: Uuid, + reason: &str, + ) -> Result<Uuid, EngineError> { + let directive = repository::get_directive(&self.pool, directive_id) + .await? + .ok_or(EngineError::DirectiveNotFound(directive_id))?; + + let current_chain = repository::get_current_chain(&self.pool, directive_id) + .await? + .ok_or(EngineError::ChainNotFound(directive_id))?; + + // Get completed and failed steps + let steps = repository::list_chain_steps(&self.pool, current_chain.id).await?; + let completed_steps: Vec<_> = steps.iter().filter(|s| s.status == "passed").collect(); + let failed_step = steps.iter().find(|s| s.status == "failed"); + + // Build replan prompt + let _prompt = self.planner.build_replan_prompt( + &directive, + &completed_steps.iter().map(|s| (*s).clone()).collect::<Vec<_>>(), + failed_step.map(|s| &*s), + reason, + ); + + // TODO: Call LLM to regenerate chain + // For now, just create a new chain with similar structure + let new_chain = self.generate_initial_chain(&directive).await?; + + // Supersede old chain + repository::supersede_chain(&self.pool, current_chain.id).await?; + + // Create new chain + let db_chain = repository::create_directive_chain( + &self.pool, + directive_id, + &new_chain.name, + Some(&new_chain.description), + Some(reason), // rationale + None, // planning_model + ) + .await?; + + // Create steps + self.create_steps_from_chain(&db_chain.id, &new_chain).await?; + + self.emit_event(EngineEvent::ChainRegenerated { + directive_id, + old_chain_id: current_chain.id, + new_chain_id: db_chain.id, + }); + + // Continue execution + self.advance_chain(directive_id).await?; + + Ok(db_chain.id) + } + + // ======================================================================== + // Step Execution + // ======================================================================== + + /// Advance chain execution: find ready steps and start them. + pub async fn advance_chain(&self, directive_id: Uuid) -> Result<(), EngineError> { + let directive = repository::get_directive(&self.pool, directive_id) + .await? + .ok_or(EngineError::DirectiveNotFound(directive_id))?; + + // Check if directive is active + if directive.status == "paused" { + return Err(EngineError::DirectivePaused); + } + if directive.status != "active" { + return Ok(()); // Not an error, just nothing to do + } + + // Check circuit breakers + self.check_circuit_breakers(&directive).await?; + + // Get current chain + let chain = repository::get_current_chain(&self.pool, directive_id) + .await? + .ok_or(EngineError::ChainNotFound(directive_id))?; + + // Find ready steps (dependencies met, status=pending) + let ready_steps = repository::find_ready_steps(&self.pool, chain.id).await?; + + // Start each ready step + for step in ready_steps { + self.start_step(&directive, &step).await?; + } + + // Check if chain is complete + let all_steps = repository::list_chain_steps(&self.pool, chain.id).await?; + let all_passed = all_steps.iter().all(|s| s.status == "passed" || s.status == "skipped"); + let any_blocked = all_steps.iter().any(|s| s.status == "blocked" || s.status == "failed"); + + if all_passed && !all_steps.is_empty() { + // Complete the directive + self.complete_directive(directive_id).await?; + } else if any_blocked { + // Check if we should regenerate or fail + let failed_count = all_steps.iter().filter(|s| s.status == "failed").count(); + if failed_count > 3 { + // Too many failures, fail the directive + repository::update_directive_status(&self.pool, directive_id, "failed").await?; + } + } + + Ok(()) + } + + /// Start a step by creating its contract and supervisor task. + async fn start_step(&self, directive: &Directive, step: &ChainStep) -> Result<(), EngineError> { + // Update step status to ready + repository::update_step_status(&self.pool, step.id, "ready").await?; + self.emit_event(EngineEvent::StepStatusChanged { + directive_id: directive.id, + step_id: step.id, + old_status: "pending".to_string(), + new_status: "ready".to_string(), + }); + + // Get contract details from step template + let (_name, _description, _contract_type, _initial_phase) = + self.get_contract_details(directive, step); + + // TODO: Actually create the contract via the contracts handler + // For now, just update the step status to running + // In a full implementation, this would: + // 1. Create contract via POST /api/v1/contracts + // 2. Create supervisor task via POST /api/v1/tasks + // 3. Link contract and task to step + // 4. Update step status to running + + // Placeholder: mark step as running + repository::update_step_status(&self.pool, step.id, "running").await?; + self.emit_event(EngineEvent::StepStatusChanged { + directive_id: directive.id, + step_id: step.id, + old_status: "ready".to_string(), + new_status: "running".to_string(), + }); + + self.emit_directive_event( + directive.id, + "step_started", + "info", + serde_json::json!({ + "step_id": step.id, + "step_name": step.name, + }), + "system", + ) + .await?; + + Ok(()) + } + + /// Build contract details from a step. + /// Returns (name, description, contract_type, initial_phase) + fn get_contract_details( + &self, + directive: &Directive, + step: &ChainStep, + ) -> (String, Option<String>, String, String) { + let name = format!("{} - {}", directive.title, step.name); + let description = step.description.clone(); + let contract_type = step.contract_type.clone(); + let initial_phase = step.initial_phase.clone().unwrap_or_else(|| "plan".to_string()); + + (name, description, contract_type, initial_phase) + } + + // ======================================================================== + // Evaluation + // ======================================================================== + + /// Handle contract completion: evaluate the step. + pub async fn on_contract_completed( + &self, + contract_id: Uuid, + ) -> Result<(), EngineError> { + // Find the step for this contract + let step = repository::get_step_by_contract_id(&self.pool, contract_id) + .await? + .ok_or(EngineError::StepNotFound(contract_id))?; + + // Get directive + let chain = repository::get_directive_chain(&self.pool, step.chain_id) + .await? + .ok_or(EngineError::ChainNotFound(step.chain_id))?; + + let directive = repository::get_directive(&self.pool, chain.directive_id) + .await? + .ok_or(EngineError::DirectiveNotFound(chain.directive_id))?; + + // Update step status to evaluating + repository::update_step_status(&self.pool, step.id, "evaluating").await?; + self.emit_event(EngineEvent::StepStatusChanged { + directive_id: directive.id, + step_id: step.id, + old_status: "running".to_string(), + new_status: "evaluating".to_string(), + }); + + // Run evaluation + let result = self.evaluate_step(&directive, &step).await?; + + // Record evaluation + let programmatic_results = result + .verifier_results + .iter() + .filter(|r| r.verifier_type != super::verifier::VerifierType::Llm) + .map(|r| serde_json::to_value(r).unwrap_or(serde_json::Value::Null)) + .collect::<Vec<_>>(); + + let llm_results = result + .verifier_results + .iter() + .filter(|r| r.verifier_type == super::verifier::VerifierType::Llm) + .map(|r| serde_json::to_value(r).unwrap_or(serde_json::Value::Null)) + .collect::<Vec<_>>(); + + // Get chain_id from step + let chain_id = step.chain_id; + + let _evaluation = repository::create_directive_evaluation( + &self.pool, + directive.id, + Some(chain_id), + Some(step.id), + step.contract_id, + "composite", + Some("orchestration_engine"), + result.passed, + Some(result.composite_score), + Some(result.confidence_level.as_str()), + serde_json::Value::Array(programmatic_results), + serde_json::Value::Array(llm_results), + serde_json::Value::Null, // criteria_results + &result.summary, + result.rework_instructions.as_deref(), + ) + .await?; + + // Update step based on result + let new_status = match result.confidence_level { + ConfidenceLevel::Green => "passed", + ConfidenceLevel::Yellow => { + // Check autonomy level + if directive.autonomy_level == "full_auto" { + "passed" // Accept yellow in full auto mode + } else { + // Create approval request + self.request_approval( + &directive, + &step, + "step_review", + &format!( + "Step '{}' completed with yellow confidence ({:.0}%). Review required.", + step.name, + result.composite_score * 100.0 + ), + ) + .await?; + "evaluating" // Wait for approval + } + } + ConfidenceLevel::Red => { + // Initiate rework + self.initiate_rework(&directive, &step, &result).await?; + "rework" + } + }; + + repository::update_step_status(&self.pool, step.id, new_status).await?; + repository::update_step_confidence( + &self.pool, + step.id, + result.composite_score, + result.confidence_level.as_str(), + result.id, + ) + .await?; + + self.emit_event(EngineEvent::EvaluationCompleted { + directive_id: directive.id, + step_id: step.id, + passed: result.passed, + confidence_level: result.confidence_level, + }); + + // If passed, continue chain execution + if new_status == "passed" { + self.advance_chain(directive.id).await?; + } + + Ok(()) + } + + /// Evaluate a step using tiered verification. + async fn evaluate_step( + &self, + directive: &Directive, + step: &ChainStep, + ) -> Result<EvaluationResult, EngineError> { + // Get repository path + let repo_path = directive + .local_path + .as_ref() + .map(std::path::PathBuf::from) + .unwrap_or_else(|| std::path::PathBuf::from(".")); + + // Auto-detect verifiers + let verifiers = auto_detect_verifiers(&repo_path).await; + + // Build verification context + let context = VerificationContext { + step_id: step.id, + contract_id: step.contract_id, + modified_files: vec![], // TODO: Get from contract/git + step_description: step.description.clone().unwrap_or_default(), + acceptance_criteria: vec![], // TODO: Get from directive + directive_context: directive.goal.clone(), + }; + + // Run composite evaluation + let evaluator = CompositeEvaluator::new(verifiers) + .with_thresholds( + directive.confidence_threshold_green, + directive.confidence_threshold_yellow, + ); + + Ok(evaluator.evaluate(&repo_path, &context).await) + } + + /// Initiate rework for a failed step. + async fn initiate_rework( + &self, + directive: &Directive, + step: &ChainStep, + result: &EvaluationResult, + ) -> Result<(), EngineError> { + // Increment rework count + let updated_step = repository::increment_step_rework_count(&self.pool, step.id).await?; + + // Check rework limit + let max_rework = directive.max_rework_cycles.unwrap_or(3); + if updated_step.rework_count >= max_rework { + // Too many rework attempts, mark as blocked + repository::update_step_status(&self.pool, step.id, "blocked").await?; + self.emit_directive_event( + directive.id, + "step_blocked", + "warning", + serde_json::json!({ + "step_id": step.id, + "step_name": step.name, + "reason": "Max rework attempts reached", + }), + "system", + ) + .await?; + return Ok(()); + } + + // Log rework event + self.emit_directive_event( + directive.id, + "step_rework", + "info", + serde_json::json!({ + "step_id": step.id, + "step_name": step.name, + "rework_count": updated_step.rework_count, + "instructions": result.rework_instructions, + }), + "system", + ) + .await?; + + // TODO: Send rework instructions to supervisor task + // This would involve: + // 1. Reset contract phase to 'plan' + // 2. Send message to supervisor with rework instructions + // 3. Update step status to 'running' + + Ok(()) + } + + /// Request human approval for a step. + async fn request_approval( + &self, + directive: &Directive, + step: &ChainStep, + approval_type: &str, + description: &str, + ) -> Result<Uuid, EngineError> { + let context = serde_json::json!({ + "step_id": step.id, + "step_name": step.name, + "confidence_score": step.confidence_score, + }); + + let approval = repository::create_approval_request( + &self.pool, + directive.id, + Some(step.id), + approval_type, + description, + Some(context), + "medium", + None, // expires_at + ) + .await?; + + self.emit_event(EngineEvent::ApprovalRequired { + directive_id: directive.id, + approval_id: approval.id, + approval_type: approval_type.to_string(), + }); + + Ok(approval.id) + } + + /// Handle approval resolution. + pub async fn on_approval_resolved( + &self, + approval_id: Uuid, + approved: bool, + responded_by: Uuid, + ) -> Result<(), EngineError> { + let status = if approved { "approved" } else { "denied" }; + let approval = repository::resolve_approval( + &self.pool, + approval_id, + status, + None, + responded_by, + ) + .await?; + + if let Some(step_id) = approval.step_id { + let step = repository::get_chain_step(&self.pool, step_id) + .await? + .ok_or(EngineError::StepNotFound(step_id))?; + + let chain = repository::get_directive_chain(&self.pool, step.chain_id) + .await? + .ok_or(EngineError::ChainNotFound(step.chain_id))?; + + if approved { + // Mark step as passed and continue + repository::update_step_status(&self.pool, step_id, "passed").await?; + self.advance_chain(chain.directive_id).await?; + } else { + // Mark step as failed/blocked + repository::update_step_status(&self.pool, step_id, "blocked").await?; + } + } + + Ok(()) + } + + // ======================================================================== + // Circuit Breakers + // ======================================================================== + + /// Check circuit breakers for a directive. + async fn check_circuit_breakers(&self, directive: &Directive) -> Result<(), EngineError> { + // Check cost limit + if let Some(max_cost) = directive.max_total_cost_usd { + let current_cost = directive.total_cost_usd; + if current_cost >= max_cost { + return Err(EngineError::CircuitBreaker(format!( + "Cost limit exceeded: ${:.2} >= ${:.2}", + current_cost, max_cost + ))); + } + } + + // Check time limit (stored in minutes) + if let Some(max_minutes) = directive.max_wall_time_minutes { + if let Some(started_at) = directive.started_at { + let elapsed = chrono::Utc::now().signed_duration_since(started_at); + let elapsed_minutes = elapsed.num_minutes(); + if elapsed_minutes >= max_minutes as i64 { + return Err(EngineError::CircuitBreaker(format!( + "Time limit exceeded: {} min >= {} min", + elapsed_minutes, max_minutes + ))); + } + } + } + + // Check chain generation limit + if let Some(max_gen) = directive.max_chain_regenerations { + let current_gen = directive.chain_generation_count; + if current_gen >= max_gen { + return Err(EngineError::CircuitBreaker(format!( + "Chain generation limit exceeded: {} >= {}", + current_gen, max_gen + ))); + } + } + + Ok(()) + } + + // ======================================================================== + // Completion + // ======================================================================== + + /// Complete a directive after all steps pass. + async fn complete_directive(&self, directive_id: Uuid) -> Result<(), EngineError> { + // Run final evaluation (optional) + // TODO: LLM evaluation of overall directive completion + + // Update directive status + repository::update_directive_status(&self.pool, directive_id, "completed").await?; + + self.emit_event(EngineEvent::DirectiveStatusChanged { + directive_id, + old_status: "active".to_string(), + new_status: "completed".to_string(), + }); + + self.emit_directive_event( + directive_id, + "directive_completed", + "info", + serde_json::json!({}), + "system", + ) + .await?; + + Ok(()) + } + + // ======================================================================== + // Event Logging + // ======================================================================== + + /// Emit a directive event to the database. + async fn emit_directive_event( + &self, + directive_id: Uuid, + event_type: &str, + severity: &str, + event_data: serde_json::Value, + actor_type: &str, + ) -> Result<DirectiveEvent, EngineError> { + Ok(repository::emit_directive_event( + &self.pool, + directive_id, + None, // chain_id + None, // step_id + event_type, + severity, + Some(event_data), + actor_type, + None, // actor_id + ) + .await?) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_confidence_level_decision() { + // Green confidence should pass in all modes + assert_eq!(ConfidenceLevel::Green.as_str(), "green"); + + // Yellow confidence behavior depends on autonomy level + assert_eq!(ConfidenceLevel::Yellow.as_str(), "yellow"); + + // Red confidence should always trigger rework + assert_eq!(ConfidenceLevel::Red.as_str(), "red"); + } +} diff --git a/makima/src/orchestration/mod.rs b/makima/src/orchestration/mod.rs new file mode 100644 index 0000000..41913ca --- /dev/null +++ b/makima/src/orchestration/mod.rs @@ -0,0 +1,26 @@ +//! Orchestration engine for directive-driven autonomous execution. +//! +//! This module provides the core orchestration capabilities: +//! - [`DirectiveEngine`]: Main orchestration loop that manages directive lifecycle +//! - [`ChainPlanner`]: LLM-based chain generation from directive goals +//! - [`Verifier`]: Pluggable verification system for step validation +//! +//! # Architecture +//! +//! The orchestration system follows a directive-first approach: +//! 1. Directives define goals, requirements, and acceptance criteria +//! 2. Chains are generated execution plans (DAGs of steps) +//! 3. Steps map to contracts that are created and monitored +//! 4. Tiered verification (programmatic first, then LLM) determines confidence +//! 5. Confidence scoring (green/yellow/red) drives autonomy decisions + +mod engine; +mod planner; +mod verifier; + +pub use engine::{DirectiveEngine, EngineError}; +pub use planner::{ChainPlanner, PlannerError}; +pub use verifier::{ + auto_detect_verifiers, CompositeEvaluator, ConfidenceLevel, EvaluationResult, Verifier, + VerifierError, VerifierResult, VerifierType, +}; diff --git a/makima/src/orchestration/planner.rs b/makima/src/orchestration/planner.rs new file mode 100644 index 0000000..cdca8a0 --- /dev/null +++ b/makima/src/orchestration/planner.rs @@ -0,0 +1,742 @@ +//! Chain planner for LLM-based execution plan generation. +//! +//! Generates chains (DAGs of steps) from directive goals and requirements. +//! Supports both initial plan generation and replanning while preserving +//! completed work. + +use serde::{Deserialize, Serialize}; +use std::collections::{HashMap, HashSet}; +use thiserror::Error; +use uuid::Uuid; + +use crate::db::models::{AddStepRequest, ChainStep, Directive}; + +/// Error type for planner operations. +#[derive(Error, Debug)] +pub enum PlannerError { + #[error("Cycle detected in DAG: {0}")] + CycleDetected(String), + + #[error("Invalid dependency: step '{step}' depends on unknown step '{dependency}'")] + InvalidDependency { step: String, dependency: String }, + + #[error("LLM generation failed: {0}")] + LlmError(String), + + #[error("Requirement not covered: {0}")] + RequirementNotCovered(String), + + #[error("Invalid plan: {0}")] + InvalidPlan(String), + + #[error("Empty plan generated")] + EmptyPlan, +} + +/// Generated step from LLM planning. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct GeneratedStep { + /// Unique name within the chain + pub name: String, + /// Type of step (e.g., "research", "implement", "test", "review") + pub step_type: String, + /// Description of what this step accomplishes + pub description: String, + /// Names of steps this depends on + pub depends_on: Vec<String>, + /// IDs of requirements this step addresses + pub requirement_ids: Vec<String>, + /// Contract template fields + pub contract_template: Option<ContractTemplate>, +} + +/// Template for contract creation from step. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ContractTemplate { + /// Contract name + pub name: String, + /// Contract description + pub description: String, + /// Contract type (e.g., "simple", "agentic") + pub contract_type: String, + /// Phases for the contract + pub phases: Vec<String>, + /// Tasks within the contract + pub tasks: Vec<TaskTemplate>, + /// Deliverables expected + pub deliverables: Vec<DeliverableTemplate>, +} + +/// Template for task within contract. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct TaskTemplate { + pub name: String, + pub plan: String, +} + +/// Template for deliverable. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct DeliverableTemplate { + pub id: String, + pub name: String, + pub priority: String, +} + +/// Generated chain from planning. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct GeneratedChain { + /// Name for the chain + pub name: String, + /// Description of the execution plan + pub description: String, + /// Steps in the chain + pub steps: Vec<GeneratedStep>, +} + +/// Chain planner for LLM-based plan generation. +pub struct ChainPlanner { + /// Default step types to suggest (reserved for future use) + #[allow(dead_code)] + default_step_types: Vec<String>, +} + +impl Default for ChainPlanner { + fn default() -> Self { + Self::new() + } +} + +impl ChainPlanner { + /// Create a new chain planner. + pub fn new() -> Self { + Self { + default_step_types: vec![ + "research".to_string(), + "design".to_string(), + "implement".to_string(), + "test".to_string(), + "review".to_string(), + "document".to_string(), + ], + } + } + + /// Build a planning prompt for the LLM. + pub fn build_planning_prompt(&self, directive: &Directive) -> String { + let requirements: Vec<String> = directive + .requirements + .as_array() + .map(|arr| { + arr.iter() + .filter_map(|v| v.as_object()) + .map(|obj| { + let id = obj.get("id").and_then(|v| v.as_str()).unwrap_or("?"); + let desc = obj + .get("description") + .and_then(|v| v.as_str()) + .unwrap_or("?"); + format!("- {}: {}", id, desc) + }) + .collect() + }) + .unwrap_or_default(); + + let criteria: Vec<String> = directive + .acceptance_criteria + .as_array() + .map(|arr| { + arr.iter() + .filter_map(|v| v.as_object()) + .map(|obj| { + let id = obj.get("id").and_then(|v| v.as_str()).unwrap_or("?"); + let criterion = obj + .get("criterion") + .and_then(|v| v.as_str()) + .unwrap_or("?"); + format!("- {}: {}", id, criterion) + }) + .collect() + }) + .unwrap_or_default(); + + let constraints: Vec<String> = directive + .constraints + .as_array() + .map(|arr| { + arr.iter() + .filter_map(|v| v.as_str()) + .map(|s| format!("- {}", s)) + .collect() + }) + .unwrap_or_default(); + + format!( + r#"You are a software architect planning an execution chain for a coding task. + +## Directive Goal +{goal} + +## Requirements +{requirements} + +## Acceptance Criteria +{criteria} + +## Constraints +{constraints} + +## Instructions + +Create an execution plan as a chain of steps. Each step should: +1. Have a unique, descriptive name (kebab-case) +2. Specify its type (research, design, implement, test, review, document) +3. Declare dependencies on prior steps (if any) +4. Map to specific requirement IDs it addresses +5. Include a contract template with tasks and deliverables + +The chain should form a valid DAG (no cycles). Steps can run in parallel if they don't depend on each other. + +Respond with a JSON object in this format: +```json +{{ + "name": "chain-name", + "description": "Brief description of the plan", + "steps": [ + {{ + "name": "step-name", + "step_type": "implement", + "description": "What this step does", + "depends_on": ["prior-step-name"], + "requirement_ids": ["REQ-001"], + "contract_template": {{ + "name": "Contract Name", + "description": "Contract description", + "contract_type": "simple", + "phases": ["plan", "execute"], + "tasks": [ + {{"name": "Task 1", "plan": "Detailed plan for this task"}} + ], + "deliverables": [ + {{"id": "del-1", "name": "Deliverable 1", "priority": "required"}} + ] + }} + }} + ] +}} +``` + +Generate the optimal execution plan now."#, + goal = directive.goal, + requirements = requirements.join("\n"), + criteria = criteria.join("\n"), + constraints = constraints.join("\n"), + ) + } + + /// Parse LLM response into a generated chain. + pub fn parse_plan_response(&self, response: &str) -> Result<GeneratedChain, PlannerError> { + // Extract JSON from response (may be wrapped in markdown code blocks) + let json_str = extract_json_from_response(response)?; + + let chain: GeneratedChain = serde_json::from_str(&json_str) + .map_err(|e| PlannerError::InvalidPlan(format!("JSON parse error: {}", e)))?; + + if chain.steps.is_empty() { + return Err(PlannerError::EmptyPlan); + } + + // Validate the chain + self.validate_chain(&chain)?; + + Ok(chain) + } + + /// Validate a generated chain. + pub fn validate_chain(&self, chain: &GeneratedChain) -> Result<(), PlannerError> { + // Build step name set + let step_names: HashSet<&str> = chain.steps.iter().map(|s| s.name.as_str()).collect(); + + // Check for duplicate names + if step_names.len() != chain.steps.len() { + return Err(PlannerError::InvalidPlan( + "Duplicate step names detected".to_string(), + )); + } + + // Validate dependencies exist + for step in &chain.steps { + for dep in &step.depends_on { + if !step_names.contains(dep.as_str()) { + return Err(PlannerError::InvalidDependency { + step: step.name.clone(), + dependency: dep.clone(), + }); + } + } + } + + // Check for cycles using DFS + self.detect_cycles(chain)?; + + Ok(()) + } + + /// Detect cycles in the chain DAG using DFS. + fn detect_cycles(&self, chain: &GeneratedChain) -> Result<(), PlannerError> { + let mut visited = HashSet::new(); + let mut rec_stack = HashSet::new(); + + // Build adjacency map + let adj: HashMap<&str, Vec<&str>> = chain + .steps + .iter() + .map(|s| (s.name.as_str(), s.depends_on.iter().map(|d| d.as_str()).collect())) + .collect(); + + for step in &chain.steps { + if !visited.contains(step.name.as_str()) { + if self.has_cycle(&step.name, &adj, &mut visited, &mut rec_stack) { + return Err(PlannerError::CycleDetected(step.name.clone())); + } + } + } + + Ok(()) + } + + fn has_cycle<'a>( + &self, + node: &'a str, + adj: &HashMap<&'a str, Vec<&'a str>>, + visited: &mut HashSet<&'a str>, + rec_stack: &mut HashSet<&'a str>, + ) -> bool { + visited.insert(node); + rec_stack.insert(node); + + if let Some(deps) = adj.get(node) { + for &dep in deps { + if !visited.contains(dep) { + if self.has_cycle(dep, adj, visited, rec_stack) { + return true; + } + } else if rec_stack.contains(dep) { + return true; + } + } + } + + rec_stack.remove(node); + false + } + + /// Check that all requirements are covered by at least one step. + pub fn check_requirement_coverage( + &self, + chain: &GeneratedChain, + directive: &Directive, + ) -> Result<(), PlannerError> { + let required_ids: HashSet<String> = directive + .requirements + .as_array() + .map(|arr| { + arr.iter() + .filter_map(|v| v.get("id").and_then(|id| id.as_str())) + .map(|s| s.to_string()) + .collect() + }) + .unwrap_or_default(); + + let covered_ids: HashSet<String> = chain + .steps + .iter() + .flat_map(|s| s.requirement_ids.clone()) + .collect(); + + for req_id in required_ids { + if !covered_ids.contains(&req_id) { + return Err(PlannerError::RequirementNotCovered(req_id)); + } + } + + Ok(()) + } + + /// Get topological order of steps. + pub fn topological_sort<'a>( + &self, + chain: &'a GeneratedChain, + ) -> Result<Vec<&'a str>, PlannerError> { + let mut in_degree: HashMap<&str, usize> = HashMap::new(); + let mut adj: HashMap<&str, Vec<&str>> = HashMap::new(); + + // Initialize + for step in &chain.steps { + in_degree.entry(step.name.as_str()).or_insert(0); + adj.entry(step.name.as_str()).or_insert_with(Vec::new); + } + + // Build graph (reversed - edges from dependency to dependent) + for step in &chain.steps { + for dep in &step.depends_on { + adj.entry(dep.as_str()) + .or_insert_with(Vec::new) + .push(step.name.as_str()); + *in_degree.entry(step.name.as_str()).or_insert(0) += 1; + } + } + + // Kahn's algorithm + let mut queue: Vec<&str> = in_degree + .iter() + .filter(|&(_, deg)| *deg == 0) + .map(|(&name, _)| name) + .collect(); + + let mut result = Vec::new(); + + while let Some(node) = queue.pop() { + result.push(node); + + if let Some(neighbors) = adj.get(node) { + for &neighbor in neighbors { + let deg = in_degree.get_mut(neighbor).unwrap(); + *deg -= 1; + if *deg == 0 { + queue.push(neighbor); + } + } + } + } + + if result.len() != chain.steps.len() { + return Err(PlannerError::CycleDetected( + "Cycle detected during topological sort".to_string(), + )); + } + + Ok(result) + } + + /// Convert generated steps to AddStepRequest for database insertion. + pub fn steps_to_requests( + &self, + chain: &GeneratedChain, + step_id_map: &HashMap<String, Uuid>, + ) -> Vec<AddStepRequest> { + chain + .steps + .iter() + .map(|step| { + let depends_on: Vec<Uuid> = step + .depends_on + .iter() + .filter_map(|name| step_id_map.get(name)) + .copied() + .collect(); + + let task_plan = step + .contract_template + .as_ref() + .and_then(|t| t.tasks.first()) + .map(|t| t.plan.clone()); + + AddStepRequest { + name: step.name.clone(), + description: Some(step.description.clone()), + step_type: Some(step.step_type.clone()), + contract_type: step.contract_template.as_ref().map(|t| t.contract_type.clone()), + initial_phase: Some("plan".to_string()), + task_plan, + phases: step.contract_template.as_ref().map(|t| t.phases.clone()), + depends_on: Some(depends_on), + parallel_group: None, + requirement_ids: Some(step.requirement_ids.clone()), + acceptance_criteria_ids: None, + verifier_config: None, + editor_x: None, + editor_y: None, + } + }) + .collect() + } + + /// Compute editor positions for steps based on DAG layout. + pub fn compute_editor_positions( + &self, + chain: &GeneratedChain, + ) -> HashMap<String, (f64, f64)> { + let depths = self.get_step_depths(chain); + let mut positions: HashMap<String, (f64, f64)> = HashMap::new(); + + // Group by depth + let mut by_depth: HashMap<usize, Vec<&str>> = HashMap::new(); + for step in &chain.steps { + let depth = depths.get(&step.name).copied().unwrap_or(0); + by_depth.entry(depth).or_default().push(&step.name); + } + + // Compute positions: x based on depth, y based on index within depth + let x_spacing = 250.0; + let y_spacing = 150.0; + + for (depth, steps) in &by_depth { + let x = (*depth as f64) * x_spacing + 100.0; + for (i, name) in steps.iter().enumerate() { + let y = (i as f64) * y_spacing + 100.0; + positions.insert(name.to_string(), (x, y)); + } + } + + positions + } + + /// Get depth of each step in the DAG. + fn get_step_depths(&self, chain: &GeneratedChain) -> HashMap<String, usize> { + let mut depths: HashMap<String, usize> = HashMap::new(); + + // Build dependency map + let deps: HashMap<String, Vec<String>> = chain + .steps + .iter() + .map(|s| (s.name.clone(), s.depends_on.clone())) + .collect(); + + fn compute_depth( + name: &str, + deps: &HashMap<String, Vec<String>>, + depths: &mut HashMap<String, usize>, + ) -> usize { + if let Some(&d) = depths.get(name) { + return d; + } + + let depth = deps + .get(name) + .map(|dep_list| { + dep_list + .iter() + .map(|d| compute_depth(d, deps, depths) + 1) + .max() + .unwrap_or(0) + }) + .unwrap_or(0); + + depths.insert(name.to_string(), depth); + depth + } + + for step in &chain.steps { + compute_depth(&step.name, &deps, &mut depths); + } + + depths + } + + /// Build a replanning prompt that preserves completed steps. + pub fn build_replan_prompt( + &self, + directive: &Directive, + completed_steps: &[ChainStep], + failed_step: Option<&ChainStep>, + reason: &str, + ) -> String { + let completed_summary: Vec<String> = completed_steps + .iter() + .map(|s| format!("- {} ({}): completed", s.name, s.step_type)) + .collect(); + + let failed_summary = failed_step + .map(|s| format!("Failed step: {} - {}", s.name, s.description.as_deref().unwrap_or(""))) + .unwrap_or_default(); + + format!( + r#"You are a software architect replanning an execution chain. + +## Original Goal +{goal} + +## Completed Steps (preserve these) +{completed} + +## Failure Information +{failed} +Reason: {reason} + +## Instructions +Generate a new execution plan that: +1. Preserves all completed work +2. Addresses the failure +3. Continues toward the original goal + +Use the same JSON format as before. Do not include already completed steps."#, + goal = directive.goal, + completed = completed_summary.join("\n"), + failed = failed_summary, + reason = reason, + ) + } +} + +/// Extract JSON from LLM response (handles markdown code blocks). +fn extract_json_from_response(response: &str) -> Result<String, PlannerError> { + // Try to find JSON in code block + if let Some(start) = response.find("```json") { + let json_start = start + 7; + if let Some(end) = response[json_start..].find("```") { + return Ok(response[json_start..json_start + end].trim().to_string()); + } + } + + // Try to find JSON in generic code block + if let Some(start) = response.find("```") { + let block_start = start + 3; + // Skip language identifier if present + let json_start = response[block_start..] + .find('\n') + .map(|i| block_start + i + 1) + .unwrap_or(block_start); + if let Some(end) = response[json_start..].find("```") { + return Ok(response[json_start..json_start + end].trim().to_string()); + } + } + + // Try to parse the whole thing as JSON + if response.trim().starts_with('{') { + return Ok(response.trim().to_string()); + } + + Err(PlannerError::InvalidPlan( + "Could not extract JSON from response".to_string(), + )) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn make_test_chain() -> GeneratedChain { + GeneratedChain { + name: "test-chain".to_string(), + description: "Test chain".to_string(), + steps: vec![ + GeneratedStep { + name: "step-a".to_string(), + step_type: "research".to_string(), + description: "Research step".to_string(), + depends_on: vec![], + requirement_ids: vec!["REQ-001".to_string()], + contract_template: None, + }, + GeneratedStep { + name: "step-b".to_string(), + step_type: "implement".to_string(), + description: "Implementation step".to_string(), + depends_on: vec!["step-a".to_string()], + requirement_ids: vec!["REQ-002".to_string()], + contract_template: None, + }, + GeneratedStep { + name: "step-c".to_string(), + step_type: "test".to_string(), + description: "Test step".to_string(), + depends_on: vec!["step-b".to_string()], + requirement_ids: vec!["REQ-001".to_string()], + contract_template: None, + }, + ], + } + } + + #[test] + fn test_validate_chain_valid() { + let planner = ChainPlanner::new(); + let chain = make_test_chain(); + assert!(planner.validate_chain(&chain).is_ok()); + } + + #[test] + fn test_validate_chain_invalid_dependency() { + let planner = ChainPlanner::new(); + let mut chain = make_test_chain(); + chain.steps[1].depends_on = vec!["nonexistent".to_string()]; + + let result = planner.validate_chain(&chain); + assert!(matches!(result, Err(PlannerError::InvalidDependency { .. }))); + } + + #[test] + fn test_validate_chain_cycle() { + let planner = ChainPlanner::new(); + let chain = GeneratedChain { + name: "cyclic".to_string(), + description: "Has cycle".to_string(), + steps: vec![ + GeneratedStep { + name: "a".to_string(), + step_type: "research".to_string(), + description: "A".to_string(), + depends_on: vec!["c".to_string()], + requirement_ids: vec![], + contract_template: None, + }, + GeneratedStep { + name: "b".to_string(), + step_type: "implement".to_string(), + description: "B".to_string(), + depends_on: vec!["a".to_string()], + requirement_ids: vec![], + contract_template: None, + }, + GeneratedStep { + name: "c".to_string(), + step_type: "test".to_string(), + description: "C".to_string(), + depends_on: vec!["b".to_string()], + requirement_ids: vec![], + contract_template: None, + }, + ], + }; + + let result = planner.validate_chain(&chain); + assert!(matches!(result, Err(PlannerError::CycleDetected(_)))); + } + + #[test] + fn test_topological_sort() { + let planner = ChainPlanner::new(); + let chain = make_test_chain(); + let order = planner.topological_sort(&chain).unwrap(); + + // step-a must come before step-b, step-b before step-c + let pos_a = order.iter().position(|&n| n == "step-a").unwrap(); + let pos_b = order.iter().position(|&n| n == "step-b").unwrap(); + let pos_c = order.iter().position(|&n| n == "step-c").unwrap(); + + assert!(pos_a < pos_b); + assert!(pos_b < pos_c); + } + + #[test] + fn test_extract_json_from_code_block() { + let response = r#" +Here's the plan: + +```json +{"name": "test"} +``` + +That's it! +"#; + let json = extract_json_from_response(response).unwrap(); + assert_eq!(json, r#"{"name": "test"}"#); + } + + #[test] + fn test_extract_json_raw() { + let response = r#"{"name": "test"}"#; + let json = extract_json_from_response(response).unwrap(); + assert_eq!(json, r#"{"name": "test"}"#); + } +} diff --git a/makima/src/orchestration/verifier.rs b/makima/src/orchestration/verifier.rs new file mode 100644 index 0000000..e98da50 --- /dev/null +++ b/makima/src/orchestration/verifier.rs @@ -0,0 +1,806 @@ +//! Verification system for directive step evaluation. +//! +//! Provides tiered verification: programmatic verifiers run first, +//! then LLM evaluation if programmatic checks pass. Composite scoring +//! combines results with configurable weights. + +use async_trait::async_trait; +use serde::{Deserialize, Serialize}; +use serde_json::Value as JsonValue; +use std::path::Path; +use thiserror::Error; +use uuid::Uuid; + +/// Confidence level based on composite score and thresholds. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum ConfidenceLevel { + /// High confidence (score >= green threshold) + Green, + /// Medium confidence (score >= yellow threshold but < green) + Yellow, + /// Low confidence (score < yellow threshold) + Red, +} + +impl ConfidenceLevel { + /// Compute confidence level from score and thresholds. + pub fn from_score(score: f64, green_threshold: f64, yellow_threshold: f64) -> Self { + if score >= green_threshold { + ConfidenceLevel::Green + } else if score >= yellow_threshold { + ConfidenceLevel::Yellow + } else { + ConfidenceLevel::Red + } + } + + /// Convert to string for database storage. + pub fn as_str(&self) -> &'static str { + match self { + ConfidenceLevel::Green => "green", + ConfidenceLevel::Yellow => "yellow", + ConfidenceLevel::Red => "red", + } + } +} + +impl std::fmt::Display for ConfidenceLevel { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.as_str()) + } +} + +/// Type of verifier for categorization. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum VerifierType { + /// Run test suite (npm test, cargo test, pytest, etc.) + TestRunner, + /// Run linter (eslint, clippy, ruff, etc.) + Linter, + /// Run type checker (tsc, mypy, etc.) + TypeChecker, + /// Run build command (npm build, cargo build, etc.) + Build, + /// Custom command verifier + Custom, + /// LLM-based semantic evaluation + Llm, +} + +impl VerifierType { + pub fn as_str(&self) -> &'static str { + match self { + VerifierType::TestRunner => "test_runner", + VerifierType::Linter => "linter", + VerifierType::TypeChecker => "type_checker", + VerifierType::Build => "build", + VerifierType::Custom => "custom", + VerifierType::Llm => "llm", + } + } +} + +/// Result of a single verifier run. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct VerifierResult { + /// Name of the verifier + pub name: String, + /// Type of verifier + pub verifier_type: VerifierType, + /// Whether the verification passed + pub passed: bool, + /// Score from 0.0 to 1.0 (1.0 = perfect, 0.0 = complete failure) + pub score: f64, + /// Weight for composite scoring (default 1.0 for programmatic, 2.0 for LLM) + pub weight: f64, + /// Whether this verifier is required (failure = automatic red confidence) + pub required: bool, + /// Human-readable output/feedback + pub output: String, + /// Structured details (test counts, lint errors, etc.) + pub details: Option<JsonValue>, + /// Execution time in milliseconds + pub duration_ms: u64, +} + +impl VerifierResult { + /// Create a passed result with full score. + pub fn passed(name: String, verifier_type: VerifierType, output: String) -> Self { + Self { + name, + verifier_type, + passed: true, + score: 1.0, + weight: 1.0, + required: false, + output, + details: None, + duration_ms: 0, + } + } + + /// Create a failed result with zero score. + pub fn failed(name: String, verifier_type: VerifierType, output: String) -> Self { + Self { + name, + verifier_type, + passed: false, + score: 0.0, + weight: 1.0, + required: false, + output, + details: None, + duration_ms: 0, + } + } + + /// Set the weight for this result. + pub fn with_weight(mut self, weight: f64) -> Self { + self.weight = weight; + self + } + + /// Mark this verifier as required. + pub fn as_required(mut self) -> Self { + self.required = true; + self + } + + /// Set the score explicitly. + pub fn with_score(mut self, score: f64) -> Self { + self.score = score.clamp(0.0, 1.0); + self + } + + /// Set structured details. + pub fn with_details(mut self, details: JsonValue) -> Self { + self.details = Some(details); + self + } + + /// Set execution duration. + pub fn with_duration(mut self, duration_ms: u64) -> Self { + self.duration_ms = duration_ms; + self + } +} + +/// Composite evaluation result combining multiple verifier results. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct EvaluationResult { + /// Unique ID for this evaluation + pub id: Uuid, + /// Step ID being evaluated + pub step_id: Uuid, + /// Whether all required verifiers passed + pub passed: bool, + /// Weighted composite score (0.0-1.0) + pub composite_score: f64, + /// Confidence level derived from score + pub confidence_level: ConfidenceLevel, + /// Individual verifier results + pub verifier_results: Vec<VerifierResult>, + /// Summary feedback for the step + pub summary: String, + /// Rework instructions if failed + pub rework_instructions: Option<String>, + /// Total evaluation duration in milliseconds + pub total_duration_ms: u64, +} + +impl EvaluationResult { + /// Create a new evaluation result from verifier results. + pub fn from_verifiers( + step_id: Uuid, + results: Vec<VerifierResult>, + green_threshold: f64, + yellow_threshold: f64, + ) -> Self { + let id = Uuid::new_v4(); + + // Check if any required verifier failed + let any_required_failed = results.iter().any(|r| r.required && !r.passed); + + // Calculate weighted composite score + let (total_weighted_score, total_weight) = + results + .iter() + .fold((0.0, 0.0), |(score_acc, weight_acc), r| { + (score_acc + r.score * r.weight, weight_acc + r.weight) + }); + + let composite_score = if total_weight > 0.0 { + total_weighted_score / total_weight + } else { + 0.0 + }; + + // Override confidence to red if any required verifier failed + let confidence_level = if any_required_failed { + ConfidenceLevel::Red + } else { + ConfidenceLevel::from_score(composite_score, green_threshold, yellow_threshold) + }; + + let passed = !any_required_failed && confidence_level != ConfidenceLevel::Red; + + // Generate summary + let passed_count = results.iter().filter(|r| r.passed).count(); + let total_count = results.len(); + let summary = format!( + "{}/{} verifiers passed, composite score: {:.2}, confidence: {}", + passed_count, total_count, composite_score, confidence_level + ); + + // Generate rework instructions if failed + let rework_instructions = if !passed { + let failed_verifiers: Vec<&str> = results + .iter() + .filter(|r| !r.passed) + .map(|r| r.name.as_str()) + .collect(); + Some(format!( + "Fix issues identified by: {}", + failed_verifiers.join(", ") + )) + } else { + None + }; + + let total_duration_ms = results.iter().map(|r| r.duration_ms).sum(); + + Self { + id, + step_id, + passed, + composite_score, + confidence_level, + verifier_results: results, + summary, + rework_instructions, + total_duration_ms, + } + } +} + +/// Error type for verification operations. +#[derive(Error, Debug)] +pub enum VerifierError { + #[error("Command execution failed: {0}")] + CommandFailed(String), + + #[error("Command timed out after {0}ms")] + Timeout(u64), + + #[error("Working directory not found: {0}")] + WorkingDirectoryNotFound(String), + + #[error("Verifier not configured: {0}")] + NotConfigured(String), + + #[error("Parse error: {0}")] + ParseError(String), + + #[error("LLM error: {0}")] + LlmError(String), + + #[error("IO error: {0}")] + Io(#[from] std::io::Error), +} + +/// Verifier trait for pluggable verification implementations. +#[async_trait] +pub trait Verifier: Send + Sync { + /// Get the name of this verifier. + fn name(&self) -> &str; + + /// Get the type of this verifier. + fn verifier_type(&self) -> VerifierType; + + /// Check if this verifier is applicable to the given repository. + async fn is_applicable(&self, repo_path: &Path) -> bool; + + /// Run verification and return result. + async fn verify(&self, repo_path: &Path, context: &VerificationContext) + -> Result<VerifierResult, VerifierError>; +} + +/// Context provided to verifiers during execution. +#[derive(Debug, Clone)] +pub struct VerificationContext { + /// Step ID being verified + pub step_id: Uuid, + /// Contract ID if step has been instantiated + pub contract_id: Option<Uuid>, + /// Files that were modified in this step + pub modified_files: Vec<String>, + /// Step description for LLM context + pub step_description: String, + /// Acceptance criteria for LLM evaluation + pub acceptance_criteria: Vec<String>, + /// Additional context from directive + pub directive_context: String, +} + +/// Command-based verifier for running shell commands. +pub struct CommandVerifier { + name: String, + verifier_type: VerifierType, + command: String, + #[allow(dead_code)] + working_dir: Option<String>, + #[allow(dead_code)] + timeout_ms: u64, + required: bool, + /// Files/patterns that indicate this verifier is applicable + applicable_patterns: Vec<String>, +} + +impl CommandVerifier { + /// Create a new command verifier. + pub fn new( + name: impl Into<String>, + verifier_type: VerifierType, + command: impl Into<String>, + ) -> Self { + Self { + name: name.into(), + verifier_type, + command: command.into(), + working_dir: None, + timeout_ms: 300_000, // 5 minute default + required: false, + applicable_patterns: Vec::new(), + } + } + + /// Set the working directory. + #[allow(dead_code)] + pub fn with_working_dir(mut self, dir: impl Into<String>) -> Self { + self.working_dir = Some(dir.into()); + self + } + + /// Set the timeout in milliseconds. + #[allow(dead_code)] + pub fn with_timeout(mut self, timeout_ms: u64) -> Self { + self.timeout_ms = timeout_ms; + self + } + + /// Mark as required verifier. + pub fn as_required(mut self) -> Self { + self.required = true; + self + } + + /// Add applicability patterns (files that must exist). + pub fn with_patterns(mut self, patterns: Vec<String>) -> Self { + self.applicable_patterns = patterns; + self + } +} + +#[async_trait] +impl Verifier for CommandVerifier { + fn name(&self) -> &str { + &self.name + } + + fn verifier_type(&self) -> VerifierType { + self.verifier_type.clone() + } + + async fn is_applicable(&self, repo_path: &Path) -> bool { + if self.applicable_patterns.is_empty() { + return true; + } + + for pattern in &self.applicable_patterns { + let check_path = repo_path.join(pattern); + if check_path.exists() { + return true; + } + } + false + } + + async fn verify( + &self, + repo_path: &Path, + _context: &VerificationContext, + ) -> Result<VerifierResult, VerifierError> { + let start = std::time::Instant::now(); + + let work_dir = self + .working_dir + .as_ref() + .map(|d| repo_path.join(d)) + .unwrap_or_else(|| repo_path.to_path_buf()); + + if !work_dir.exists() { + return Err(VerifierError::WorkingDirectoryNotFound( + work_dir.display().to_string(), + )); + } + + // Parse command into program and args + let parts: Vec<&str> = self.command.split_whitespace().collect(); + if parts.is_empty() { + return Err(VerifierError::CommandFailed( + "Empty command".to_string(), + )); + } + + let program = parts[0]; + let args = &parts[1..]; + + // Execute command + let output = tokio::process::Command::new(program) + .args(args) + .current_dir(&work_dir) + .output() + .await?; + + let duration_ms = start.elapsed().as_millis() as u64; + let stdout = String::from_utf8_lossy(&output.stdout); + let stderr = String::from_utf8_lossy(&output.stderr); + let combined_output = format!("{}\n{}", stdout, stderr); + + let passed = output.status.success(); + let score = if passed { 1.0 } else { 0.0 }; + + let mut result = VerifierResult { + name: self.name.clone(), + verifier_type: self.verifier_type.clone(), + passed, + score, + weight: 1.0, + required: self.required, + output: combined_output, + details: Some(serde_json::json!({ + "exit_code": output.status.code(), + "command": self.command, + "working_dir": work_dir.display().to_string(), + })), + duration_ms, + }; + + // Try to extract more detailed scoring from output + result = self.enhance_result(result, &stdout); + + Ok(result) + } +} + +impl CommandVerifier { + /// Enhance result with parsed details from output. + fn enhance_result(&self, mut result: VerifierResult, stdout: &str) -> VerifierResult { + match self.verifier_type { + VerifierType::TestRunner => { + // Try to parse test counts from common formats + if let Some((passed, failed, total)) = parse_test_output(stdout) { + result.details = Some(serde_json::json!({ + "tests_passed": passed, + "tests_failed": failed, + "tests_total": total, + "command": self.command, + })); + if total > 0 { + result.score = passed as f64 / total as f64; + } + } + } + VerifierType::Linter => { + // Try to parse lint error counts + if let Some(error_count) = parse_lint_output(stdout) { + result.details = Some(serde_json::json!({ + "errors": error_count, + "command": self.command, + })); + // Score decreases with more errors (up to 10 errors = 0) + result.score = (1.0 - (error_count as f64 / 10.0)).max(0.0); + } + } + _ => {} + } + result + } +} + +/// Parse test output for common formats (Jest, pytest, cargo test). +fn parse_test_output(output: &str) -> Option<(u32, u32, u32)> { + // Jest format: "Tests: X passed, Y failed, Z total" + if let Some(caps) = regex::Regex::new(r"Tests:\s*(\d+)\s*passed,\s*(\d+)\s*failed,\s*(\d+)\s*total") + .ok()? + .captures(output) + { + let passed: u32 = caps.get(1)?.as_str().parse().ok()?; + let failed: u32 = caps.get(2)?.as_str().parse().ok()?; + let total: u32 = caps.get(3)?.as_str().parse().ok()?; + return Some((passed, failed, total)); + } + + // pytest format: "X passed, Y failed" + if let Some(caps) = regex::Regex::new(r"(\d+)\s*passed(?:,\s*(\d+)\s*failed)?") + .ok()? + .captures(output) + { + let passed: u32 = caps.get(1)?.as_str().parse().ok()?; + let failed: u32 = caps.get(2).map(|m| m.as_str().parse().ok()).flatten().unwrap_or(0); + let total = passed + failed; + return Some((passed, failed, total)); + } + + // cargo test format: "test result: ok. X passed; Y failed;" + if let Some(caps) = regex::Regex::new(r"test result:.*?(\d+)\s*passed;\s*(\d+)\s*failed") + .ok()? + .captures(output) + { + let passed: u32 = caps.get(1)?.as_str().parse().ok()?; + let failed: u32 = caps.get(2)?.as_str().parse().ok()?; + let total = passed + failed; + return Some((passed, failed, total)); + } + + None +} + +/// Parse lint output for error counts. +fn parse_lint_output(output: &str) -> Option<u32> { + // ESLint format: "X problems (Y errors, Z warnings)" + if let Some(caps) = regex::Regex::new(r"(\d+)\s*problems?\s*\((\d+)\s*errors?") + .ok()? + .captures(output) + { + return caps.get(2)?.as_str().parse().ok(); + } + + // Clippy format: "warning: X warnings emitted" + if let Some(caps) = regex::Regex::new(r"warning:\s*(\d+)\s*warnings?\s*emitted") + .ok()? + .captures(output) + { + return caps.get(1)?.as_str().parse().ok(); + } + + None +} + +/// Auto-detect applicable verifiers for a repository. +pub async fn auto_detect_verifiers(repo_path: &Path) -> Vec<Box<dyn Verifier>> { + let mut verifiers: Vec<Box<dyn Verifier>> = Vec::new(); + + // Check for package.json (Node.js) + let package_json = repo_path.join("package.json"); + if package_json.exists() { + if let Ok(content) = tokio::fs::read_to_string(&package_json).await { + if let Ok(pkg) = serde_json::from_str::<serde_json::Value>(&content) { + if let Some(scripts) = pkg.get("scripts").and_then(|s| s.as_object()) { + // Test runner + if scripts.contains_key("test") { + verifiers.push(Box::new( + CommandVerifier::new("npm-test", VerifierType::TestRunner, "npm test") + .with_patterns(vec!["package.json".to_string()]) + .as_required(), + )); + } + + // Linter + if scripts.contains_key("lint") { + verifiers.push(Box::new( + CommandVerifier::new("npm-lint", VerifierType::Linter, "npm run lint") + .with_patterns(vec!["package.json".to_string()]), + )); + } + + // Build + if scripts.contains_key("build") { + verifiers.push(Box::new( + CommandVerifier::new("npm-build", VerifierType::Build, "npm run build") + .with_patterns(vec!["package.json".to_string()]) + .as_required(), + )); + } + + // Type check (for TypeScript projects) + if scripts.contains_key("typecheck") || scripts.contains_key("type-check") { + let cmd = if scripts.contains_key("typecheck") { + "npm run typecheck" + } else { + "npm run type-check" + }; + verifiers.push(Box::new( + CommandVerifier::new("npm-typecheck", VerifierType::TypeChecker, cmd) + .with_patterns(vec!["tsconfig.json".to_string()]), + )); + } + } + } + } + } + + // Check for Cargo.toml (Rust) + let cargo_toml = repo_path.join("Cargo.toml"); + if cargo_toml.exists() { + verifiers.push(Box::new( + CommandVerifier::new("cargo-test", VerifierType::TestRunner, "cargo test") + .with_patterns(vec!["Cargo.toml".to_string()]) + .as_required(), + )); + + verifiers.push(Box::new( + CommandVerifier::new("cargo-clippy", VerifierType::Linter, "cargo clippy -- -D warnings") + .with_patterns(vec!["Cargo.toml".to_string()]), + )); + + verifiers.push(Box::new( + CommandVerifier::new("cargo-build", VerifierType::Build, "cargo build") + .with_patterns(vec!["Cargo.toml".to_string()]) + .as_required(), + )); + } + + // Check for pyproject.toml or setup.py (Python) + let pyproject = repo_path.join("pyproject.toml"); + let setup_py = repo_path.join("setup.py"); + if pyproject.exists() || setup_py.exists() { + verifiers.push(Box::new( + CommandVerifier::new("pytest", VerifierType::TestRunner, "pytest") + .with_patterns(vec![ + "pyproject.toml".to_string(), + "setup.py".to_string(), + ]) + .as_required(), + )); + + verifiers.push(Box::new( + CommandVerifier::new("ruff", VerifierType::Linter, "ruff check .") + .with_patterns(vec!["pyproject.toml".to_string()]), + )); + } + + verifiers +} + +/// Composite evaluator that runs multiple verifiers and combines results. +pub struct CompositeEvaluator { + verifiers: Vec<Box<dyn Verifier>>, + green_threshold: f64, + yellow_threshold: f64, +} + +impl CompositeEvaluator { + /// Create a new composite evaluator with default thresholds. + pub fn new(verifiers: Vec<Box<dyn Verifier>>) -> Self { + Self { + verifiers, + green_threshold: 0.8, + yellow_threshold: 0.5, + } + } + + /// Set confidence thresholds. + pub fn with_thresholds(mut self, green: f64, yellow: f64) -> Self { + self.green_threshold = green; + self.yellow_threshold = yellow; + self + } + + /// Add a verifier. + pub fn add_verifier(mut self, verifier: Box<dyn Verifier>) -> Self { + self.verifiers.push(verifier); + self + } + + /// Run all applicable verifiers and return composite result. + pub async fn evaluate( + &self, + repo_path: &Path, + context: &VerificationContext, + ) -> EvaluationResult { + let mut results = Vec::new(); + + for verifier in &self.verifiers { + if !verifier.is_applicable(repo_path).await { + continue; + } + + match verifier.verify(repo_path, context).await { + Ok(result) => results.push(result), + Err(e) => { + // Convert error to failed result + results.push(VerifierResult::failed( + verifier.name().to_string(), + verifier.verifier_type(), + format!("Verifier error: {}", e), + )); + } + } + } + + EvaluationResult::from_verifiers( + context.step_id, + results, + self.green_threshold, + self.yellow_threshold, + ) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_confidence_level_from_score() { + assert_eq!( + ConfidenceLevel::from_score(0.9, 0.8, 0.5), + ConfidenceLevel::Green + ); + assert_eq!( + ConfidenceLevel::from_score(0.8, 0.8, 0.5), + ConfidenceLevel::Green + ); + assert_eq!( + ConfidenceLevel::from_score(0.6, 0.8, 0.5), + ConfidenceLevel::Yellow + ); + assert_eq!( + ConfidenceLevel::from_score(0.5, 0.8, 0.5), + ConfidenceLevel::Yellow + ); + assert_eq!( + ConfidenceLevel::from_score(0.4, 0.8, 0.5), + ConfidenceLevel::Red + ); + } + + #[test] + fn test_evaluation_result_composite_score() { + let results = vec![ + VerifierResult::passed("test1".into(), VerifierType::TestRunner, "OK".into()) + .with_weight(1.0), + VerifierResult::failed("test2".into(), VerifierType::Linter, "Failed".into()) + .with_weight(1.0), + ]; + + let eval = EvaluationResult::from_verifiers(Uuid::new_v4(), results, 0.8, 0.5); + assert!((eval.composite_score - 0.5).abs() < 0.001); + assert_eq!(eval.confidence_level, ConfidenceLevel::Yellow); + } + + #[test] + fn test_required_verifier_override() { + let results = vec![ + VerifierResult::passed("test1".into(), VerifierType::TestRunner, "OK".into()), + VerifierResult::failed("build".into(), VerifierType::Build, "Failed".into()) + .as_required(), + ]; + + let eval = EvaluationResult::from_verifiers(Uuid::new_v4(), results, 0.8, 0.5); + // Even though composite score is 0.5, required failure overrides to red + assert_eq!(eval.confidence_level, ConfidenceLevel::Red); + assert!(!eval.passed); + } + + #[test] + fn test_parse_test_output_jest() { + let output = "Tests: 10 passed, 2 failed, 12 total"; + let (passed, failed, total) = parse_test_output(output).unwrap(); + assert_eq!(passed, 10); + assert_eq!(failed, 2); + assert_eq!(total, 12); + } + + #[test] + fn test_parse_test_output_cargo() { + let output = "test result: ok. 25 passed; 0 failed;"; + let (passed, failed, total) = parse_test_output(output).unwrap(); + assert_eq!(passed, 25); + assert_eq!(failed, 0); + assert_eq!(total, 25); + } +} diff --git a/makima/src/server/handlers/contract_chat.rs b/makima/src/server/handlers/contract_chat.rs index 06b3a7c..8153093 100644 --- a/makima/src/server/handlers/contract_chat.rs +++ b/makima/src/server/handlers/contract_chat.rs @@ -17,8 +17,6 @@ use uuid::Uuid; use crate::db::{ models::{ ContractChatHistoryResponse, ContractWithRelations, CreateTaskRequest, UpdateFileRequest, - AddContractDefinitionRequest, UpdateContractDefinitionRequest, CreateChainRequest, - CreateChainDirectiveRequest, CreateContractEvaluationRequest, }, repository, }; @@ -2767,1211 +2765,26 @@ async fn handle_contract_request( } } - // Chain directive tools - for directive contracts to create and manage chains - ContractToolRequest::CreateChainFromDirective { name, description } => { - // First, get the current contract to verify it's a directive contract - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - // Check if contract already has a spawned chain - if contract.spawned_chain_id.is_some() { - return ContractRequestResult { - success: false, - message: "This contract already has a chain associated with it".to_string(), - data: Some(json!({ "existing_chain_id": contract.spawned_chain_id })), - }; - } - - // Create the chain - let chain_req = CreateChainRequest { - name: name.clone(), - description: description.clone(), - repositories: None, - loop_enabled: None, - loop_max_iterations: None, - loop_progress_check: None, - contracts: None, - }; - - let chain = match repository::create_chain_for_owner(pool, owner_id, chain_req).await { - Ok(c) => c, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to create chain: {}", e), - data: None, - }, - }; - - // Link the chain to this directive contract - if let Err(e) = sqlx::query( - r#" - UPDATE chains SET directive_contract_id = $2, evaluation_enabled = true WHERE id = $1; - UPDATE contracts SET spawned_chain_id = $1, is_chain_directive = true WHERE id = $2; - "#, - ) - .bind(chain.id) - .bind(contract_id) - .execute(pool) - .await { - return ContractRequestResult { - success: false, - message: format!("Failed to link chain to contract: {}", e), - data: None, - }; - } - - // Create empty directive for the chain - let directive_req = CreateChainDirectiveRequest { - requirements: Some(vec![]), - acceptance_criteria: Some(vec![]), - constraints: Some(vec![]), - external_dependencies: Some(vec![]), - source_type: Some("llm_generated".to_string()), - }; - - if let Err(e) = repository::create_chain_directive(pool, chain.id, directive_req).await { - return ContractRequestResult { - success: false, - message: format!("Failed to create directive: {}", e), - data: None, - }; - } - - ContractRequestResult { - success: true, - message: format!("Created chain '{}' linked to this directive contract", name), - data: Some(json!({ - "chain_id": chain.id, - "chain_name": name, - "description": description - })), - } - } - - ContractToolRequest::AddChainContract { name, description, contract_type, depends_on, requirement_ids } => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain. Use create_chain_from_directive first.".to_string(), - data: None, - }, - }; - - // Check for duplicate names - let existing_defs = match repository::list_chain_contract_definitions(pool, chain_id).await { - Ok(defs) => defs, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list definitions: {}", e), - data: None, - }, - }; - - if existing_defs.iter().any(|d| d.name == name) { - return ContractRequestResult { - success: false, - message: format!("A contract definition with name '{}' already exists", name), - data: None, - }; - } - - // Create the contract definition - let def_req = AddContractDefinitionRequest { - name: name.clone(), - description, - contract_type: contract_type.unwrap_or_else(|| "implementation".to_string()), - initial_phase: Some("research".to_string()), - depends_on, - tasks: None, - deliverables: None, - validation: None, - editor_x: None, - editor_y: None, - }; - - let definition = match repository::create_chain_contract_definition(pool, chain_id, def_req).await { - Ok(d) => d, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to create contract definition: {}", e), - data: None, - }, - }; - - // Update requirement_ids if provided - if let Some(req_ids) = requirement_ids { - if !req_ids.is_empty() { - if let Err(e) = sqlx::query( - "UPDATE chain_contract_definitions SET requirement_ids = $2 WHERE id = $1" - ) - .bind(definition.id) - .bind(&req_ids) - .execute(pool) - .await { - tracing::warn!("Failed to set requirement_ids: {}", e); - } - } - } - - ContractRequestResult { - success: true, - message: format!("Added contract '{}' to chain", name), - data: Some(json!({ - "definition_id": definition.id, - "name": name, - "order_index": definition.order_index - })), - } - } - - ContractToolRequest::SetChainDependencies { contract_name, depends_on } => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Find the definition by name - let definitions = match repository::list_chain_contract_definitions(pool, chain_id).await { - Ok(defs) => defs, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list definitions: {}", e), - data: None, - }, - }; - - let definition = match definitions.iter().find(|d| d.name == contract_name) { - Some(d) => d, - None => return ContractRequestResult { - success: false, - message: format!("No contract definition named '{}' found", contract_name), - data: None, - }, - }; - - // Validate that all dependencies exist - for dep_name in &depends_on { - if !definitions.iter().any(|d| &d.name == dep_name) { - return ContractRequestResult { - success: false, - message: format!("Dependency '{}' does not exist", dep_name), - data: None, - }; - } - } - - // Check for circular dependencies (simple check) - if depends_on.contains(&contract_name) { - return ContractRequestResult { - success: false, - message: "A contract cannot depend on itself".to_string(), - data: None, - }; - } - - // Update dependencies - let update_req = UpdateContractDefinitionRequest { - name: None, - description: None, - contract_type: None, - initial_phase: None, - depends_on: Some(depends_on.clone()), - tasks: None, - deliverables: None, - validation: None, - editor_x: None, - editor_y: None, - }; - - match repository::update_chain_contract_definition(pool, definition.id, update_req).await { - Ok(_) => ContractRequestResult { - success: true, - message: format!("Updated dependencies for '{}'", contract_name), - data: Some(json!({ - "contract_name": contract_name, - "depends_on": depends_on - })), - }, - Err(e) => ContractRequestResult { - success: false, - message: format!("Failed to update dependencies: {}", e), - data: None, - }, - } - } - - ContractToolRequest::ModifyChainContract { name, new_name, description, add_requirement_ids, remove_requirement_ids } => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Find the definition by name - let definitions = match repository::list_chain_contract_definitions(pool, chain_id).await { - Ok(defs) => defs, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list definitions: {}", e), - data: None, - }, - }; - - let definition = match definitions.iter().find(|d| d.name == name) { - Some(d) => d.clone(), - None => return ContractRequestResult { - success: false, - message: format!("No contract definition named '{}' found", name), - data: None, - }, - }; - - // Check if new name would conflict - if let Some(ref nn) = new_name { - if nn != &name && definitions.iter().any(|d| &d.name == nn) { - return ContractRequestResult { - success: false, - message: format!("A contract definition named '{}' already exists", nn), - data: None, - }; - } - } - - // Update the definition - let update_req = UpdateContractDefinitionRequest { - name: new_name.clone(), - description, - contract_type: None, - initial_phase: None, - depends_on: None, - tasks: None, - deliverables: None, - validation: None, - editor_x: None, - editor_y: None, - }; - - if let Err(e) = repository::update_chain_contract_definition(pool, definition.id, update_req).await { - return ContractRequestResult { - success: false, - message: format!("Failed to update definition: {}", e), - data: None, - }; - } - - // Handle requirement_ids modifications - let mut current_req_ids: Vec<String> = definition.requirement_ids.clone(); - if let Some(add_ids) = add_requirement_ids { - for id in add_ids { - if !current_req_ids.contains(&id) { - current_req_ids.push(id); - } - } - } - if let Some(remove_ids) = remove_requirement_ids { - current_req_ids.retain(|id| !remove_ids.contains(id)); - } - - if current_req_ids != definition.requirement_ids { - if let Err(e) = sqlx::query( - "UPDATE chain_contract_definitions SET requirement_ids = $2 WHERE id = $1" - ) - .bind(definition.id) - .bind(¤t_req_ids) - .execute(pool) - .await { - tracing::warn!("Failed to update requirement_ids: {}", e); - } - } - - ContractRequestResult { - success: true, - message: format!("Modified contract definition '{}'", new_name.as_ref().unwrap_or(&name)), - data: Some(json!({ - "definition_id": definition.id, - "name": new_name.as_ref().unwrap_or(&name), - "requirement_ids": current_req_ids - })), - } - } - - ContractToolRequest::RemoveChainContract { name } => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Find the definition by name - let definitions = match repository::list_chain_contract_definitions(pool, chain_id).await { - Ok(defs) => defs, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list definitions: {}", e), - data: None, - }, - }; - - let definition = match definitions.iter().find(|d| d.name == name) { - Some(d) => d, - None => return ContractRequestResult { - success: false, - message: format!("No contract definition named '{}' found", name), - data: None, - }, - }; - - // Check if other definitions depend on this one - let dependents: Vec<&str> = definitions.iter() - .filter(|d| d.depends_on_names.contains(&name)) - .map(|d| d.name.as_str()) - .collect(); - - if !dependents.is_empty() { - return ContractRequestResult { - success: false, - message: format!("Cannot remove '{}': other contracts depend on it: {}", name, dependents.join(", ")), - data: None, - }; - } - - // Delete the definition - match repository::delete_chain_contract_definition(pool, definition.id).await { - Ok(true) => ContractRequestResult { - success: true, - message: format!("Removed contract definition '{}'", name), - data: Some(json!({ "removed": name })), - }, - Ok(false) => ContractRequestResult { - success: false, - message: format!("Failed to remove '{}': not found", name), - data: None, - }, - Err(e) => ContractRequestResult { - success: false, - message: format!("Failed to remove definition: {}", e), - data: None, - }, - } - } - - ContractToolRequest::PreviewChainDag => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Get chain details and definitions - let chain = match repository::get_chain_for_owner(pool, chain_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Chain not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let definitions = match repository::list_chain_contract_definitions(pool, chain_id).await { - Ok(defs) => defs, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list definitions: {}", e), - data: None, - }, - }; - - // Build DAG representation - let nodes: Vec<serde_json::Value> = definitions.iter().map(|d| { - json!({ - "name": d.name, - "description": d.description, - "contract_type": d.contract_type, - "depends_on": d.depends_on_names, - "requirement_ids": d.requirement_ids - }) - }).collect(); - - // Build ASCII DAG representation - let mut ascii_dag = String::new(); - ascii_dag.push_str(&format!("Chain: {} ({})\n", chain.name, chain.status)); - ascii_dag.push_str(&format!("Contracts: {}\n\n", definitions.len())); - - // Find root nodes (no dependencies) - let roots: Vec<&str> = definitions.iter() - .filter(|d| d.depends_on_names.is_empty()) - .map(|d| d.name.as_str()) - .collect(); - - ascii_dag.push_str("Root contracts (no dependencies):\n"); - for root in &roots { - ascii_dag.push_str(&format!(" [{}]\n", root)); - } - - ascii_dag.push_str("\nDependency relationships:\n"); - for def in &definitions { - if !def.depends_on_names.is_empty() { - ascii_dag.push_str(&format!(" {} <- {}\n", def.name, def.depends_on_names.join(", "))); - } - } - - ContractRequestResult { - success: true, - message: format!("Chain DAG preview with {} contracts", definitions.len()), - data: Some(json!({ - "chain_id": chain_id, - "chain_name": chain.name, - "chain_status": chain.status, - "contract_count": definitions.len(), - "nodes": nodes, - "ascii_dag": ascii_dag - })), - } - } - - ContractToolRequest::ValidateChainDirective => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - let definitions = match repository::list_chain_contract_definitions(pool, chain_id).await { - Ok(defs) => defs, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list definitions: {}", e), - data: None, - }, - }; - - let mut errors: Vec<String> = Vec::new(); - let mut warnings: Vec<String> = Vec::new(); - - // Check for empty chain - if definitions.is_empty() { - errors.push("Chain has no contract definitions".to_string()); - } - - // Check for circular dependencies - let def_names: std::collections::HashSet<String> = definitions.iter().map(|d| d.name.clone()).collect(); - for def in &definitions { - for dep in &def.depends_on_names { - if !def_names.contains(dep) { - errors.push(format!("'{}' depends on non-existent contract '{}'", def.name, dep)); - } - } - } - - // Simple cycle detection using DFS - fn has_cycle( - name: &str, - definitions: &[crate::db::models::ChainContractDefinition], - visited: &mut std::collections::HashSet<String>, - rec_stack: &mut std::collections::HashSet<String>, - ) -> Option<String> { - visited.insert(name.to_string()); - rec_stack.insert(name.to_string()); - - if let Some(def) = definitions.iter().find(|d| d.name == name) { - for dep in &def.depends_on_names { - if !visited.contains(dep) { - if let Some(cycle) = has_cycle(dep, definitions, visited, rec_stack) { - return Some(cycle); - } - } else if rec_stack.contains(dep) { - return Some(format!("{} -> {}", name, dep)); - } - } - } - - rec_stack.remove(name); - None - } - - let mut visited = std::collections::HashSet::new(); - for def in &definitions { - if !visited.contains(&def.name) { - let mut rec_stack = std::collections::HashSet::new(); - if let Some(cycle) = has_cycle(&def.name, &definitions, &mut visited, &mut rec_stack) { - errors.push(format!("Circular dependency detected: {}", cycle)); - break; - } - } - } - - // Check for orphan contracts (no one depends on them and they're not root) - let roots: std::collections::HashSet<&str> = definitions.iter() - .filter(|d| d.depends_on_names.is_empty()) - .map(|d| d.name.as_str()) - .collect(); - - let depended_on: std::collections::HashSet<&str> = definitions.iter() - .flat_map(|d| d.depends_on_names.iter().map(|s| s.as_str())) - .collect(); - - for def in &definitions { - if !roots.contains(def.name.as_str()) && !depended_on.contains(def.name.as_str()) { - warnings.push(format!("'{}' has dependencies but nothing depends on it (orphan leaf)", def.name)); - } - } - - // Get directive to check requirement coverage - if let Ok(Some(directive)) = repository::get_chain_directive(pool, chain_id).await { - let requirements: Vec<crate::db::models::DirectiveRequirement> = - serde_json::from_value(directive.requirements.clone()).unwrap_or_default(); - - let covered: std::collections::HashSet<&str> = definitions.iter() - .flat_map(|d| d.requirement_ids.iter().map(|s| s.as_str())) - .collect(); - - for req in &requirements { - if !covered.contains(req.id.as_str()) { - warnings.push(format!("Requirement '{}' ({}) is not covered by any contract", req.id, req.title)); - } - } - } - - let is_valid = errors.is_empty(); - - ContractRequestResult { - success: is_valid, - message: if is_valid { - format!("Chain is valid with {} contracts", definitions.len()) - } else { - format!("Chain validation failed with {} errors", errors.len()) - }, - data: Some(json!({ - "valid": is_valid, - "contract_count": definitions.len(), - "errors": errors, - "warnings": warnings - })), - } - } - - ContractToolRequest::FinalizeChainDirective { auto_start } => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Get chain - let chain = match repository::get_chain_for_owner(pool, chain_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Chain not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - if chain.status != "pending" { - return ContractRequestResult { - success: false, - message: format!("Chain is already {} - cannot finalize", chain.status), - data: None, - }; - } - - // Update chain status - let new_status = if auto_start { "active" } else { "pending" }; - if let Err(e) = sqlx::query("UPDATE chains SET status = $2 WHERE id = $1") - .bind(chain_id) - .bind(new_status) - .execute(pool) - .await { - return ContractRequestResult { - success: false, - message: format!("Failed to update chain status: {}", e), - data: None, - }; - } - - // If auto_start, trigger chain progression to create root contracts - if auto_start { - match repository::progress_chain(pool, chain_id, owner_id).await { - Ok(result) => { - ContractRequestResult { - success: true, - message: format!("Chain finalized and started. Created {} root contracts.", result.contracts_created.len()), - data: Some(json!({ - "chain_id": chain_id, - "status": "active", - "contracts_created": result.contracts_created, - "chain_completed": result.chain_completed - })), - } - } - Err(e) => ContractRequestResult { - success: false, - message: format!("Chain finalized but failed to start: {}", e), - data: Some(json!({ "chain_id": chain_id, "status": "active" })), - }, - } - } else { - ContractRequestResult { - success: true, - message: "Chain finalized but not started. Call finalize_chain_directive with auto_start=true to start.".to_string(), - data: Some(json!({ - "chain_id": chain_id, - "status": "pending" - })), - } - } - } - - ContractToolRequest::GetChainStatus => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Get chain details - let chain = match repository::get_chain_for_owner(pool, chain_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Chain not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - // Get definitions - let definitions = match repository::list_chain_contract_definitions(pool, chain_id).await { - Ok(defs) => defs, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list definitions: {}", e), - data: None, - }, - }; - - // Get instantiated contracts - let chain_contracts = match repository::list_chain_contracts(pool, chain_id).await { - Ok(cc) => cc, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list chain contracts: {}", e), - data: None, - }, - }; - - // Build status map - let contract_statuses: Vec<serde_json::Value> = chain_contracts.iter().map(|cc| { - json!({ - "name": cc.contract_name, - "contract_id": cc.contract_id, - "status": cc.contract_status, - "phase": cc.contract_phase, - "evaluation_status": cc.evaluation_status, - "evaluation_retry_count": cc.evaluation_retry_count - }) - }).collect(); - - let completed = chain_contracts.iter().filter(|cc| cc.contract_status == "completed").count(); - let active = chain_contracts.iter().filter(|cc| cc.contract_status == "active").count(); - let pending = definitions.len() - chain_contracts.len(); - - ContractRequestResult { - success: true, - message: format!("Chain '{}': {} completed, {} active, {} pending", - chain.name, completed, active, pending), - data: Some(json!({ - "chain_id": chain_id, - "chain_name": chain.name, - "chain_status": chain.status, - "total_definitions": definitions.len(), - "instantiated": chain_contracts.len(), - "completed": completed, - "active": active, - "pending": pending, - "contracts": contract_statuses - })), - } - } - - ContractToolRequest::GetUncoveredRequirements => { - // Get the contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Get directive - let directive = match repository::get_chain_directive(pool, chain_id).await { - Ok(Some(d)) => d, - Ok(None) => return ContractRequestResult { - success: true, - message: "No directive found for this chain".to_string(), - data: Some(json!({ "uncovered": [], "total_requirements": 0 })), - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - // Get definitions - let definitions = match repository::list_chain_contract_definitions(pool, chain_id).await { - Ok(defs) => defs, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to list definitions: {}", e), - data: None, - }, - }; - - // Parse requirements - let requirements: Vec<crate::db::models::DirectiveRequirement> = - serde_json::from_value(directive.requirements.clone()).unwrap_or_default(); - - // Find covered requirement IDs - let covered: std::collections::HashSet<String> = definitions.iter() - .flat_map(|d| d.requirement_ids.iter().cloned()) - .collect(); - - // Find uncovered requirements - let uncovered: Vec<serde_json::Value> = requirements.iter() - .filter(|r| !covered.contains(&r.id)) - .map(|r| json!({ - "id": r.id, - "title": r.title, - "priority": r.priority - })) - .collect(); - - ContractRequestResult { - success: true, - message: format!("{} of {} requirements are uncovered", uncovered.len(), requirements.len()), - data: Some(json!({ - "uncovered": uncovered, - "uncovered_count": uncovered.len(), - "total_requirements": requirements.len(), - "coverage_percent": if requirements.is_empty() { 100.0 } else { - ((requirements.len() - uncovered.len()) as f64 / requirements.len() as f64 * 100.0).round() - } - })), - } - } - - ContractToolRequest::EvaluateContractCompletion { contract_id: target_contract_id, passed, feedback, rework_instructions } => { - // Get the directive contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Verify the target contract is part of this chain - let chain_contract = match repository::get_chain_contract_by_contract_id(pool, target_contract_id).await { - Ok(Some(cc)) => cc, - Ok(None) => return ContractRequestResult { - success: false, - message: format!("Contract {} is not part of a chain", target_contract_id), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - if chain_contract.chain_id != chain_id { - return ContractRequestResult { - success: false, - message: "Contract is not part of this directive's chain".to_string(), - data: None, - }; - } - - // Create evaluation record - let eval_req = CreateContractEvaluationRequest { - contract_id: target_contract_id, - chain_id: Some(chain_id), - chain_contract_id: Some(chain_contract.id), - evaluator_model: Some("directive_contract".to_string()), - passed, - overall_score: if passed { Some(1.0) } else { Some(0.0) }, - criteria_results: vec![], - summary_feedback: feedback.clone(), - rework_instructions: rework_instructions.clone(), - }; - - let evaluation = match repository::create_contract_evaluation(pool, eval_req).await { - Ok(e) => e, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Failed to create evaluation: {}", e), - data: None, - }, - }; - - // Update chain contract evaluation status - let new_status = if passed { "passed" } else { "failed" }; - if let Err(e) = repository::update_chain_contract_evaluation_status( - pool, - chain_contract.id, - new_status, - Some(evaluation.id), - None, // No rework feedback for passed/failed status - ).await { - tracing::warn!("Failed to update chain contract evaluation status: {}", e); - } - - if passed { - // Progress the chain to create downstream contracts - match repository::progress_chain(pool, chain_id, owner_id).await { - Ok(result) => ContractRequestResult { - success: true, - message: format!("Evaluation passed. Created {} downstream contracts.", result.contracts_created.len()), - data: Some(json!({ - "evaluation_id": evaluation.id, - "passed": true, - "contracts_created": result.contracts_created, - "chain_completed": result.chain_completed - })), - }, - Err(e) => ContractRequestResult { - success: true, - message: format!("Evaluation passed but failed to progress chain: {}", e), - data: Some(json!({ - "evaluation_id": evaluation.id, - "passed": true - })), - }, - } - } else { - // Mark contract for rework - if let Err(e) = sqlx::query( - r#" - UPDATE chain_contracts SET evaluation_status = 'rework', rework_feedback = $2 WHERE id = $1; - UPDATE contracts SET status = 'active' WHERE id = (SELECT contract_id FROM chain_contracts WHERE id = $1); - "# - ) - .bind(chain_contract.id) - .bind(&rework_instructions) - .execute(pool) - .await { - tracing::warn!("Failed to mark contract for rework: {}", e); - } - - ContractRequestResult { - success: true, - message: format!("Evaluation failed. Contract marked for rework."), - data: Some(json!({ - "evaluation_id": evaluation.id, - "passed": false, - "rework_instructions": rework_instructions, - "retry_count": chain_contract.evaluation_retry_count + 1 - })), - } - } - } - - ContractToolRequest::RequestRework { contract_id: target_contract_id, feedback } => { - // Get the directive contract's spawned chain - let contract = match repository::get_contract_for_owner(pool, contract_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => return ContractRequestResult { - success: false, - message: "Contract not found".to_string(), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - let chain_id = match contract.spawned_chain_id { - Some(id) => id, - None => return ContractRequestResult { - success: false, - message: "This contract has no associated chain".to_string(), - data: None, - }, - }; - - // Verify the target contract is part of this chain - let chain_contract = match repository::get_chain_contract_by_contract_id(pool, target_contract_id).await { - Ok(Some(cc)) => cc, - Ok(None) => return ContractRequestResult { - success: false, - message: format!("Contract {} is not part of a chain", target_contract_id), - data: None, - }, - Err(e) => return ContractRequestResult { - success: false, - message: format!("Database error: {}", e), - data: None, - }, - }; - - if chain_contract.chain_id != chain_id { - return ContractRequestResult { - success: false, - message: "Contract is not part of this directive's chain".to_string(), - data: None, - }; - } - - // Check retry count - let max_retries = chain_contract.max_evaluation_retries; - if chain_contract.evaluation_retry_count >= max_retries { - return ContractRequestResult { - success: false, - message: format!("Contract has exceeded max retries ({}/{}). Escalate to user.", - chain_contract.evaluation_retry_count, max_retries), - data: Some(json!({ - "retry_count": chain_contract.evaluation_retry_count, - "max_retries": max_retries, - "escalation_required": true - })), - }; - } - - // Mark contract for rework and increment retry count - if let Err(e) = sqlx::query( - r#" - UPDATE chain_contracts - SET evaluation_status = 'rework', - rework_feedback = $2, - evaluation_retry_count = evaluation_retry_count + 1 - WHERE id = $1; - UPDATE contracts SET status = 'active' WHERE id = (SELECT contract_id FROM chain_contracts WHERE id = $1); - "# - ) - .bind(chain_contract.id) - .bind(&feedback) - .execute(pool) - .await { - return ContractRequestResult { - success: false, - message: format!("Failed to request rework: {}", e), - data: None, - }; - } + // Chain directive tools - TEMPORARILY DISABLED + // These tools will be reimplemented using the new directive system. + // See the orchestration module for the new implementation. + ContractToolRequest::CreateChainFromDirective { .. } | + ContractToolRequest::AddChainContract { .. } | + ContractToolRequest::SetChainDependencies { .. } | + ContractToolRequest::ModifyChainContract { .. } | + ContractToolRequest::RemoveChainContract { .. } | + ContractToolRequest::PreviewChainDag | + ContractToolRequest::ValidateChainDirective | + ContractToolRequest::FinalizeChainDirective { .. } | + ContractToolRequest::GetChainStatus | + ContractToolRequest::GetUncoveredRequirements | + ContractToolRequest::EvaluateContractCompletion { .. } | + ContractToolRequest::RequestRework { .. } => { ContractRequestResult { - success: true, - message: format!("Rework requested for contract. Retry {}/{}", - chain_contract.evaluation_retry_count + 1, max_retries), - data: Some(json!({ - "contract_id": target_contract_id, - "retry_count": chain_contract.evaluation_retry_count + 1, - "max_retries": max_retries, - "feedback": feedback - })), + success: false, + message: "Chain directive tools are temporarily disabled. The directive system is being reimplemented.".to_string(), + data: None, } } } diff --git a/makima/src/server/handlers/contracts.rs b/makima/src/server/handlers/contracts.rs index 2b2fc26..8a6ce0f 100644 --- a/makima/src/server/handlers/contracts.rs +++ b/makima/src/server/handlers/contracts.rs @@ -575,78 +575,90 @@ pub async fn update_contract( }), ).await; - // If contract is part of a chain, check evaluation requirements - if let Some(chain_id) = contract.chain_id { - let pool_clone = pool.clone(); - let owner_id = auth.owner_id; - let contract_id = contract.id; - tokio::spawn(async move { - // Check if chain has evaluation enabled - let chain = match repository::get_chain_for_owner(&pool_clone, chain_id, owner_id).await { - Ok(Some(c)) => c, - Ok(None) => { - tracing::warn!(chain_id = %chain_id, "Chain not found for progression"); - return; - } - Err(e) => { - tracing::error!(chain_id = %chain_id, error = %e, "Failed to get chain"); - return; - } - }; - - // If evaluation is enabled, mark contract for evaluation - if chain.evaluation_enabled { - // Mark the chain_contract as pending evaluation - if let Ok(Some(chain_contract)) = repository::get_chain_contract_by_contract_id(&pool_clone, contract_id).await { - if let Err(e) = repository::update_chain_contract_evaluation_status( - &pool_clone, - chain_contract.id, - "pending_evaluation", - None, - None, - ).await { - tracing::error!( - chain_id = %chain_id, - contract_id = %contract_id, - error = %e, - "Failed to mark contract for evaluation" - ); - } else { - tracing::info!( - chain_id = %chain_id, - contract_id = %contract_id, - "Contract marked for evaluation - waiting for directive contract to evaluate" + // If contract is part of a directive chain step, update the step status + // and emit an event for the directive engine to process + let pool_for_step = pool.clone(); + let contract_id_for_step = contract.id; + tokio::spawn(async move { + // Look up the step by contract_id + match repository::get_step_by_contract_id(&pool_for_step, contract_id_for_step).await { + Ok(Some(step)) => { + // Get the chain to find the directive_id + let directive_id = match repository::get_directive_chain(&pool_for_step, step.chain_id).await { + Ok(Some(chain)) => chain.directive_id, + Ok(None) => { + tracing::warn!( + chain_id = %step.chain_id, + "Chain not found for step" ); + return; } - } - // Don't progress chain - directive contract will evaluate and progress - return; - } - - // If evaluation is disabled, progress chain directly - match repository::progress_chain(&pool_clone, chain_id, owner_id).await { - Ok(result) => { - if !result.contracts_created.is_empty() { - tracing::info!( - chain_id = %chain_id, - contracts_created = ?result.contracts_created, - "Chain progressed - created new contracts" + Err(e) => { + tracing::warn!( + chain_id = %step.chain_id, + error = %e, + "Failed to get chain for step" ); + return; } - if result.chain_completed { - tracing::info!(chain_id = %chain_id, "Chain completed"); - } - } - Err(e) => { - tracing::error!( - chain_id = %chain_id, + }; + + // Update step status to 'evaluating' + if let Err(e) = repository::update_step_status(&pool_for_step, step.id, "evaluating").await { + tracing::warn!( + step_id = %step.id, + contract_id = %contract_id_for_step, error = %e, - "Failed to progress chain after contract completion" + "Failed to update step status to evaluating" ); + } else { + tracing::info!( + step_id = %step.id, + contract_id = %contract_id_for_step, + chain_id = %step.chain_id, + directive_id = %directive_id, + "Contract completed - step transitioned to evaluating" + ); + + // Emit directive event for contract completion + if let Err(e) = repository::emit_directive_event( + &pool_for_step, + directive_id, + Some(step.chain_id), + Some(step.id), + "contract_completed", + "info", + Some(serde_json::json!({ + "contract_id": contract_id_for_step, + "step_id": step.id, + "step_name": step.name + })), + "system", + None, + ).await { + tracing::warn!( + step_id = %step.id, + error = %e, + "Failed to emit contract_completed directive event" + ); + } } } - }); - } + Ok(None) => { + tracing::debug!( + contract_id = %contract_id_for_step, + "Contract not linked to any directive chain step" + ); + } + Err(e) => { + tracing::warn!( + contract_id = %contract_id_for_step, + error = %e, + "Failed to look up step for completed contract" + ); + } + } + }); } // Get summary with counts diff --git a/makima/src/server/handlers/directives.rs b/makima/src/server/handlers/directives.rs new file mode 100644 index 0000000..6f6c3f1 --- /dev/null +++ b/makima/src/server/handlers/directives.rs @@ -0,0 +1,1488 @@ +//! API handlers for directives. +//! +//! Provides REST endpoints for managing directives, chains, steps, +//! evaluations, events, verifiers, and approvals. + +use axum::{ + extract::{Path, Query, State}, + http::StatusCode, + response::{ + sse::{Event, Sse}, + IntoResponse, + }, + Json, +}; +use futures::stream; +use serde::{Deserialize, Serialize}; +use std::convert::Infallible; +use std::time::Duration; +use uuid::Uuid; + +use crate::db::models::{ + AddStepRequest, CreateDirectiveRequest, CreateVerifierRequest, UpdateDirectiveRequest, + UpdateStepRequest, UpdateVerifierRequest, +}; +use crate::db::repository; +use crate::server::auth::Authenticated; +use crate::server::messages::ApiError; +use crate::server::state::SharedState; + +/// Query parameters for listing directives +#[derive(Debug, Deserialize)] +pub struct ListDirectivesQuery { + pub status: Option<String>, +} + +/// Query parameters for listing events +#[derive(Debug, Deserialize)] +pub struct ListEventsQuery { + pub limit: Option<i64>, +} + +/// Query parameters for listing evaluations +#[derive(Debug, Deserialize)] +pub struct ListEvaluationsQuery { + pub limit: Option<i64>, + #[serde(rename = "stepId")] + pub step_id: Option<Uuid>, +} + +/// Response for directive creation +#[derive(Debug, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct CreateDirectiveResponse { + pub id: Uuid, + pub title: String, + pub status: String, +} + +/// Response for approval actions +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ApprovalActionRequest { + pub response: Option<String>, +} + +// ============================================================================= +// Directive CRUD +// ============================================================================= + +/// Create a new directive +/// POST /api/v1/directives +pub async fn create_directive( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Json(req): Json<CreateDirectiveRequest>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + match repository::create_directive_for_owner(pool, auth.owner_id, req).await { + Ok(directive) => Json(CreateDirectiveResponse { + id: directive.id, + title: directive.title, + status: directive.status, + }) + .into_response(), + Err(e) => { + tracing::error!("Failed to create directive: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// List directives for the authenticated owner +/// GET /api/v1/directives +pub async fn list_directives( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Query(params): Query<ListDirectivesQuery>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + match repository::list_directives_for_owner(pool, auth.owner_id, params.status.as_deref()).await + { + Ok(directives) => Json(directives).into_response(), + Err(e) => { + tracing::error!("Failed to list directives: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Get a directive with progress details +/// GET /api/v1/directives/:id +pub async fn get_directive( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + match repository::get_directive_with_progress(pool, id, auth.owner_id).await { + Ok(Some(directive)) => Json(directive).into_response(), + Ok(None) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response(), + Err(e) => { + tracing::error!("Failed to get directive: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Update a directive +/// PUT /api/v1/directives/:id +pub async fn update_directive( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, + Json(req): Json<UpdateDirectiveRequest>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + match repository::update_directive_for_owner(pool, id, auth.owner_id, req).await { + Ok(directive) => Json(directive).into_response(), + Err(repository::RepositoryError::VersionConflict { expected, actual }) => ( + StatusCode::CONFLICT, + Json(ApiError::new( + "VERSION_CONFLICT", + &format!( + "Version conflict: expected {}, got {}", + expected, actual + ), + )), + ) + .into_response(), + Err(e) => { + tracing::error!("Failed to update directive: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Archive a directive +/// DELETE /api/v1/directives/:id +pub async fn archive_directive( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + match repository::archive_directive_for_owner(pool, id, auth.owner_id).await { + Ok(true) => StatusCode::NO_CONTENT.into_response(), + Ok(false) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response(), + Err(e) => { + tracing::error!("Failed to archive directive: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +// ============================================================================= +// Directive Lifecycle +// ============================================================================= + +/// Start a directive (generate chain and begin execution) +/// POST /api/v1/directives/:id/start +pub async fn start_directive( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + // Start directive via orchestration engine + let engine = crate::orchestration::DirectiveEngine::new(pool.clone()); + match engine.start_directive(id).await { + Ok(()) => { + // Return the updated directive with progress + match repository::get_directive_with_progress(pool, id, auth.owner_id).await { + Ok(Some(directive)) => Json(directive).into_response(), + Ok(None) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response(), + Err(e) => ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response(), + } + } + Err(e) => { + tracing::error!("Failed to start directive: {}", e); + ( + StatusCode::BAD_REQUEST, + Json(ApiError::new("START_FAILED", &e.to_string())), + ) + .into_response() + } + } +} + +/// Pause a directive +/// POST /api/v1/directives/:id/pause +pub async fn pause_directive( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + let engine = crate::orchestration::DirectiveEngine::new(pool.clone()); + match engine.pause_directive(id).await { + Ok(()) => match repository::get_directive(pool, id).await { + Ok(Some(directive)) => Json(directive).into_response(), + Ok(None) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response(), + Err(e) => ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response(), + }, + Err(e) => { + tracing::error!("Failed to pause directive: {}", e); + ( + StatusCode::BAD_REQUEST, + Json(ApiError::new("PAUSE_FAILED", &e.to_string())), + ) + .into_response() + } + } +} + +/// Resume a paused directive +/// POST /api/v1/directives/:id/resume +pub async fn resume_directive( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + let engine = crate::orchestration::DirectiveEngine::new(pool.clone()); + match engine.resume_directive(id).await { + Ok(()) => match repository::get_directive_with_progress(pool, id, auth.owner_id).await { + Ok(Some(directive)) => Json(directive).into_response(), + Ok(None) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response(), + Err(e) => ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response(), + }, + Err(e) => { + tracing::error!("Failed to resume directive: {}", e); + ( + StatusCode::BAD_REQUEST, + Json(ApiError::new("RESUME_FAILED", &e.to_string())), + ) + .into_response() + } + } +} + +/// Stop a directive (cannot be resumed) +/// POST /api/v1/directives/:id/stop +pub async fn stop_directive( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + let engine = crate::orchestration::DirectiveEngine::new(pool.clone()); + match engine.stop_directive(id).await { + Ok(()) => match repository::get_directive(pool, id).await { + Ok(Some(directive)) => Json(directive).into_response(), + Ok(None) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response(), + Err(e) => ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response(), + }, + Err(e) => { + tracing::error!("Failed to stop directive: {}", e); + ( + StatusCode::BAD_REQUEST, + Json(ApiError::new("STOP_FAILED", &e.to_string())), + ) + .into_response() + } + } +} + +// ============================================================================= +// Chain Management +// ============================================================================= + +/// Get current chain for a directive +/// GET /api/v1/directives/:id/chain +pub async fn get_chain( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::get_current_chain(pool, id).await { + Ok(Some(chain)) => { + match repository::list_chain_steps(pool, chain.id).await { + Ok(steps) => Json(serde_json::json!({ + "chain": chain, + "steps": steps, + })) + .into_response(), + Err(e) => ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response(), + } + } + Ok(None) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "No active chain")), + ) + .into_response(), + Err(e) => { + tracing::error!("Failed to get chain: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Get chain graph for DAG visualization +/// GET /api/v1/directives/:id/chain/graph +pub async fn get_chain_graph( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + // Get current chain + let chain = match repository::get_current_chain(pool, id).await { + Ok(Some(chain)) => chain, + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "No active chain")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + }; + + match repository::get_chain_graph(pool, chain.id).await { + Ok(graph) => Json(graph).into_response(), + Err(e) => { + tracing::error!("Failed to get chain graph: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Regenerate chain (force replan) +/// POST /api/v1/directives/:id/chain/replan +pub async fn replan_chain( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + let engine = crate::orchestration::DirectiveEngine::new(pool.clone()); + match engine.regenerate_chain(id, "Manual replan requested").await { + Ok(new_chain_id) => Json(serde_json::json!({ + "chainId": new_chain_id, + "message": "Chain regenerated successfully", + })) + .into_response(), + Err(e) => { + tracing::error!("Failed to replan chain: {}", e); + ( + StatusCode::BAD_REQUEST, + Json(ApiError::new("REPLAN_FAILED", &e.to_string())), + ) + .into_response() + } + } +} + +// ============================================================================= +// Step Management +// ============================================================================= + +/// Add a step to the current chain +/// POST /api/v1/directives/:id/chain/steps +pub async fn add_step( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, + Json(req): Json<AddStepRequest>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + // Get current chain + let chain = match repository::get_current_chain(pool, id).await { + Ok(Some(chain)) => chain, + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "No active chain")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + }; + + match repository::create_chain_step(pool, chain.id, req).await { + Ok(step) => (StatusCode::CREATED, Json(step)).into_response(), + Err(e) => { + tracing::error!("Failed to add step: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Get step details +/// GET /api/v1/directives/:id/chain/steps/:step_id +pub async fn get_step( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path((id, step_id)): Path<(Uuid, Uuid)>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::get_chain_step(pool, step_id).await { + Ok(Some(step)) => Json(step).into_response(), + Ok(None) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Step not found")), + ) + .into_response(), + Err(e) => { + tracing::error!("Failed to get step: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Update a step +/// PUT /api/v1/directives/:id/chain/steps/:step_id +pub async fn update_step( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path((id, step_id)): Path<(Uuid, Uuid)>, + Json(req): Json<UpdateStepRequest>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::update_chain_step(pool, step_id, req).await { + Ok(step) => Json(step).into_response(), + Err(e) => { + tracing::error!("Failed to update step: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Delete a step +/// DELETE /api/v1/directives/:id/chain/steps/:step_id +pub async fn delete_step( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path((id, step_id)): Path<(Uuid, Uuid)>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::delete_chain_step(pool, step_id).await { + Ok(true) => StatusCode::NO_CONTENT.into_response(), + Ok(false) => ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Step not found")), + ) + .into_response(), + Err(e) => { + tracing::error!("Failed to delete step: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Skip a step +/// POST /api/v1/directives/:id/chain/steps/:step_id/skip +pub async fn skip_step( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path((id, step_id)): Path<(Uuid, Uuid)>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::update_step_status(pool, step_id, "skipped").await { + Ok(step) => Json(step).into_response(), + Err(e) => { + tracing::error!("Failed to skip step: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +// ============================================================================= +// Evaluations +// ============================================================================= + +/// List evaluations for a directive +/// GET /api/v1/directives/:id/evaluations +pub async fn list_evaluations( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, + Query(params): Query<ListEvaluationsQuery>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + let result = if let Some(step_id) = params.step_id { + repository::list_step_evaluations(pool, step_id).await + } else { + repository::list_directive_evaluations(pool, id, params.limit).await + }; + + match result { + Ok(evaluations) => Json(evaluations).into_response(), + Err(e) => { + tracing::error!("Failed to list evaluations: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +// ============================================================================= +// Events +// ============================================================================= + +/// List events for a directive +/// GET /api/v1/directives/:id/events +pub async fn list_events( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, + Query(params): Query<ListEventsQuery>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::list_directive_events(pool, id, params.limit).await { + Ok(events) => Json(events).into_response(), + Err(e) => { + tracing::error!("Failed to list events: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// SSE stream of events for a directive +/// GET /api/v1/directives/:id/events/stream +pub async fn stream_events( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + // Create SSE stream that polls for new events + let pool_clone = pool.clone(); + let stream = stream::unfold( + (pool_clone, id, None::<chrono::DateTime<chrono::Utc>>), + move |(pool, directive_id, last_seen)| async move { + // Wait a bit before next poll + tokio::time::sleep(Duration::from_secs(1)).await; + + // Get recent events + let events = repository::list_directive_events(&pool, directive_id, Some(10)) + .await + .unwrap_or_default(); + + // Filter to only new events + let new_events: Vec<_> = events + .into_iter() + .filter(|e| last_seen.map(|ls| e.created_at > ls).unwrap_or(true)) + .collect(); + + let new_last_seen = new_events.first().map(|e| e.created_at).or(last_seen); + + // Convert to SSE events + let sse_events: Vec<Result<Event, Infallible>> = new_events + .into_iter() + .map(|e| { + Ok(Event::default() + .event("directive_event") + .data(serde_json::to_string(&e).unwrap_or_default())) + }) + .collect(); + + Some((stream::iter(sse_events), (pool, directive_id, new_last_seen))) + }, + ); + + use futures::StreamExt; + Sse::new(stream.flatten()) + .keep_alive( + axum::response::sse::KeepAlive::new() + .interval(Duration::from_secs(15)) + .text("keepalive"), + ) + .into_response() +} + +// ============================================================================= +// Verifiers +// ============================================================================= + +/// List verifiers for a directive +/// GET /api/v1/directives/:id/verifiers +pub async fn list_verifiers( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::list_directive_verifiers(pool, id).await { + Ok(verifiers) => Json(verifiers).into_response(), + Err(e) => { + tracing::error!("Failed to list verifiers: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Add a verifier to a directive +/// POST /api/v1/directives/:id/verifiers +pub async fn add_verifier( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, + Json(req): Json<CreateVerifierRequest>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::create_directive_verifier( + pool, + id, + &req.name, + &req.verifier_type, + req.command.as_deref(), + req.working_directory.as_deref(), + false, // auto_detect + vec![], // detect_files + req.weight.unwrap_or(1.0), + req.required.unwrap_or(false), + ) + .await + { + Ok(verifier) => (StatusCode::CREATED, Json(verifier)).into_response(), + Err(e) => { + tracing::error!("Failed to add verifier: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Update a verifier +/// PUT /api/v1/directives/:id/verifiers/:verifier_id +pub async fn update_verifier( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path((id, verifier_id)): Path<(Uuid, Uuid)>, + Json(req): Json<UpdateVerifierRequest>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::update_directive_verifier( + pool, + verifier_id, + req.enabled, + req.command.as_deref(), + req.weight, + req.required, + ) + .await + { + Ok(verifier) => Json(verifier).into_response(), + Err(e) => { + tracing::error!("Failed to update verifier: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +// ============================================================================= +// Approvals +// ============================================================================= + +/// List pending approvals for a directive +/// GET /api/v1/directives/:id/approvals +pub async fn list_approvals( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(id): Path<Uuid>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + match repository::list_pending_approvals(pool, id).await { + Ok(approvals) => Json(approvals).into_response(), + Err(e) => { + tracing::error!("Failed to list approvals: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } +} + +/// Approve a pending approval request +/// POST /api/v1/directives/:id/approvals/:approval_id/approve +pub async fn approve_request( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path((id, approval_id)): Path<(Uuid, Uuid)>, + Json(req): Json<ApprovalActionRequest>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + let engine = crate::orchestration::DirectiveEngine::new(pool.clone()); + match engine + .on_approval_resolved(approval_id, true, auth.owner_id) + .await + { + Ok(()) => { + match repository::resolve_approval( + pool, + approval_id, + "approved", + req.response.as_deref(), + auth.owner_id, + ) + .await + { + Ok(approval) => Json(approval).into_response(), + Err(e) => ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response(), + } + } + Err(e) => { + tracing::error!("Failed to process approval: {}", e); + ( + StatusCode::BAD_REQUEST, + Json(ApiError::new("APPROVAL_FAILED", &e.to_string())), + ) + .into_response() + } + } +} + +/// Deny a pending approval request +/// POST /api/v1/directives/:id/approvals/:approval_id/deny +pub async fn deny_request( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path((id, approval_id)): Path<(Uuid, Uuid)>, + Json(req): Json<ApprovalActionRequest>, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Verify ownership + match repository::get_directive_for_owner(pool, id, auth.owner_id).await { + Ok(Some(_)) => {} + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response() + } + Err(e) => { + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response() + } + } + + let engine = crate::orchestration::DirectiveEngine::new(pool.clone()); + match engine + .on_approval_resolved(approval_id, false, auth.owner_id) + .await + { + Ok(()) => { + match repository::resolve_approval( + pool, + approval_id, + "denied", + req.response.as_deref(), + auth.owner_id, + ) + .await + { + Ok(approval) => Json(approval).into_response(), + Err(e) => ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response(), + } + } + Err(e) => { + tracing::error!("Failed to process denial: {}", e); + ( + StatusCode::BAD_REQUEST, + Json(ApiError::new("DENIAL_FAILED", &e.to_string())), + ) + .into_response() + } + } +} diff --git a/makima/src/server/handlers/mod.rs b/makima/src/server/handlers/mod.rs index 5e172bc..d3fabf7 100644 --- a/makima/src/server/handlers/mod.rs +++ b/makima/src/server/handlers/mod.rs @@ -1,7 +1,8 @@ //! HTTP and WebSocket request handlers. pub mod api_keys; -pub mod chains; +// pub mod chains; // Removed - replaced by directives +pub mod directives; pub mod chat; pub mod contract_chat; pub mod contract_daemon; diff --git a/makima/src/server/mod.rs b/makima/src/server/mod.rs index e5b55e7..927e9a5 100644 --- a/makima/src/server/mod.rs +++ b/makima/src/server/mod.rs @@ -18,7 +18,7 @@ use tower_http::trace::TraceLayer; use utoipa::OpenApi; use utoipa_swagger_ui::SwaggerUi; -use crate::server::handlers::{api_keys, chains, chat, contract_chat, contract_daemon, contract_discuss, contracts, file_ws, files, history, listen, mesh, mesh_chat, mesh_daemon, mesh_merge, mesh_supervisor, mesh_ws, repository_history, speak, templates, transcript_analysis, users, versions}; +use crate::server::handlers::{api_keys, chat, contract_chat, contract_daemon, contract_discuss, contracts, directives, file_ws, files, history, listen, mesh, mesh_chat, mesh_daemon, mesh_merge, mesh_supervisor, mesh_ws, repository_history, speak, templates, transcript_analysis, users, versions}; use crate::server::openapi::ApiDoc; use crate::server::state::SharedState; @@ -214,51 +214,55 @@ pub fn make_router(state: SharedState) -> Router { ) // Timeline endpoint (unified history for user) .route("/timeline", get(history::get_timeline)) - // Chain endpoints (multi-contract orchestration) + // Directive endpoints (replacement for chains) .route( - "/chains", - get(chains::list_chains).post(chains::create_chain), + "/directives", + get(directives::list_directives).post(directives::create_directive), ) - .route("/chains/init", post(chains::init_chain)) .route( - "/chains/{id}", - get(chains::get_chain) - .put(chains::update_chain) - .delete(chains::delete_chain), + "/directives/{id}", + get(directives::get_directive) + .put(directives::update_directive) + .delete(directives::archive_directive), ) - .route("/chains/{id}/contracts", get(chains::get_chain_contracts)) - .route("/chains/{id}/graph", get(chains::get_chain_graph)) - .route("/chains/{id}/events", get(chains::get_chain_events)) - .route("/chains/{id}/editor", get(chains::get_chain_editor)) - // Chain contract definitions + .route("/directives/{id}/start", post(directives::start_directive)) + .route("/directives/{id}/pause", post(directives::pause_directive)) + .route("/directives/{id}/resume", post(directives::resume_directive)) + .route("/directives/{id}/stop", post(directives::stop_directive)) + // Directive chain management + .route("/directives/{id}/chain", get(directives::get_chain)) + .route("/directives/{id}/chain/graph", get(directives::get_chain_graph)) + .route("/directives/{id}/chain/replan", post(directives::replan_chain)) + // Directive step management .route( - "/chains/{id}/definitions", - get(chains::list_chain_definitions).post(chains::create_chain_definition), + "/directives/{id}/chain/steps", + post(directives::add_step), ) .route( - "/chains/{chain_id}/definitions/{definition_id}", - put(chains::update_chain_definition).delete(chains::delete_chain_definition), + "/directives/{id}/chain/steps/{step_id}", + get(directives::get_step) + .put(directives::update_step) + .delete(directives::delete_step), ) + .route("/directives/{id}/chain/steps/{step_id}/skip", post(directives::skip_step)) + // Directive evaluations + .route("/directives/{id}/evaluations", get(directives::list_evaluations)) + // Directive events + .route("/directives/{id}/events", get(directives::list_events)) + .route("/directives/{id}/events/stream", get(directives::stream_events)) + // Directive verifiers .route( - "/chains/{id}/definitions/graph", - get(chains::get_chain_definition_graph), + "/directives/{id}/verifiers", + get(directives::list_verifiers).post(directives::add_verifier), ) - // Chain control - .route("/chains/{id}/start", post(chains::start_chain)) - .route("/chains/{id}/stop", post(chains::stop_chain)) - // Chain repositories .route( - "/chains/{id}/repositories", - get(chains::list_chain_repositories).post(chains::add_chain_repository), - ) - .route( - "/chains/{chain_id}/repositories/{repository_id}", - axum::routing::delete(chains::delete_chain_repository), - ) - .route( - "/chains/{chain_id}/repositories/{repository_id}/primary", - put(chains::set_chain_repository_primary), + "/directives/{id}/verifiers/{verifier_id}", + axum::routing::put(directives::update_verifier), ) + // Directive approvals + .route("/directives/{id}/approvals", get(directives::list_approvals)) + .route("/directives/{id}/approvals/{approval_id}/approve", post(directives::approve_request)) + .route("/directives/{id}/approvals/{approval_id}/deny", post(directives::deny_request)) // Contract type templates (built-in only) .route("/contract-types", get(templates::list_contract_types)) // Settings endpoints |