stagent 0.1.9 → 0.1.10

package/src/lib/data/clear.ts

@@ -3,6 +3,7 @@ import {
   agentLogs,
   notifications,
   documents,
+  learnedContext,
   tasks,
   workflows,
   schedules,
@@ -31,6 +32,7 @@ export function clearAllData() {
   const logsDeleted = db.delete(agentLogs).run().changes;
   const notificationsDeleted = db.delete(notifications).run().changes;
   const documentsDeleted = db.delete(documents).run().changes;
+  const learnedContextDeleted = db.delete(learnedContext).run().changes;
   const tasksDeleted = db.delete(tasks).run().changes;
   const workflowsDeleted = db.delete(workflows).run().changes;
   const schedulesDeleted = db.delete(schedules).run().changes;
@@ -58,6 +60,7 @@ export function clearAllData() {
     agentLogs: logsDeleted,
     notifications: notificationsDeleted,
     documents: documentsDeleted,
+    learnedContext: learnedContextDeleted,
     files: filesDeleted,
   };
 }

package/src/lib/notifications/permissions.ts

@@ -149,6 +149,11 @@ export function getPermissionDetailEntries(
 export function getPermissionResponseLabel(response: string | null): string | null {
   if (!response) return null;
 
+  // Handle legacy plain-string responses (pre-JSON format)
+  const legacy = response.toLowerCase();
+  if (legacy === "approved" || legacy === "allowed") return "Allowed";
+  if (legacy === "denied" || legacy === "rejected") return "Denied";
+
   try {
     const parsed = JSON.parse(response) as {
       behavior?: "allow" | "deny";
@@ -164,8 +169,7 @@ export function getPermissionResponseLabel(response: string | null): string | nu
     }
 
     return null;
-  } catch (err) {
-    console.error("[permissions] Failed to parse permission response:", err);
+  } catch {
     return null;
   }
 }

package/src/lib/workflows/__tests__/assist-builder.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect } from "vitest";
+import { buildWorkflowDefinitionFromAssist } from "../assist-builder";
+import type { TaskAssistResponse } from "@/lib/agents/runtime/task-assist-types";
+
+const MAIN_TASK = {
+  title: "Build Auth System",
+  description: "Implement authentication with OAuth2",
+  agentProfile: "general",
+};
+
+function makeAssistResponse(
+  overrides: Partial<TaskAssistResponse> = {}
+): TaskAssistResponse {
+  return {
+    improvedDescription: "Build a complete auth system",
+    breakdown: [
+      { title: "Set up middleware", description: "Create auth middleware" },
+      { title: "Create endpoints", description: "Build user API endpoints" },
+      { title: "Write tests", description: "Integration tests for auth" },
+    ],
+    recommendedPattern: "sequence",
+    complexity: "complex",
+    needsCheckpoint: false,
+    reasoning: "Multi-step ordered work",
+    ...overrides,
+  };
+}
+
+describe("buildWorkflowDefinitionFromAssist", () => {
+  describe("sequence pattern", () => {
+    it("creates a sequence workflow with main task as step 1", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse(),
+      });
+
+      expect(result.pattern).toBe("sequence");
+      expect(result.steps).toHaveLength(4); // main + 3 breakdown
+      expect(result.steps[0].name).toBe("Build Auth System");
+      expect(result.steps[1].name).toBe("Set up middleware");
+      expect(result.steps[3].name).toBe("Write tests");
+    });
+
+    it("assigns profiles from main task and suggestions", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          breakdown: [
+            { title: "Research", description: "Research patterns", suggestedProfile: "researcher" },
+            { title: "Code", description: "Write code" },
+          ],
+        }),
+      });
+
+      expect(result.steps[0].agentProfile).toBe("general"); // from mainTask
+      expect(result.steps[1].agentProfile).toBe("researcher"); // from suggestion
+      expect(result.steps[2].agentProfile).toBeUndefined(); // no suggestion = undefined
+    });
+  });
+
+  describe("checkpoint pattern", () => {
+    it("preserves requiresApproval on steps", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "checkpoint",
+          breakdown: [
+            { title: "Plan", description: "Plan deployment", requiresApproval: true },
+            { title: "Deploy", description: "Execute deployment" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("checkpoint");
+      expect(result.steps[1].requiresApproval).toBe(true);
+      expect(result.steps[2].requiresApproval).toBeUndefined();
+    });
+  });
+
+  describe("parallel pattern", () => {
+    it("auto-generates synthesis step when none provided", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "parallel",
+          breakdown: [
+            { title: "Branch A", description: "Research area A" },
+            { title: "Branch B", description: "Research area B" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("parallel");
+      // main + 2 branches + auto-synthesis = 4
+      expect(result.steps).toHaveLength(4);
+      expect(result.steps[3].name).toBe("Synthesize results");
+      expect(result.steps[3].dependsOn).toEqual(["step_1", "step_2", "step_3"]);
+    });
+
+    it("preserves explicit synthesis step with dependsOn", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "parallel",
+          breakdown: [
+            { title: "Branch A", description: "Research A" },
+            { title: "Merge", description: "Merge results", dependsOn: [0, 1] },
+          ],
+        }),
+      });
+
+      // main + Branch A + Merge = 3 (no auto-synthesis because dependsOn exists)
+      expect(result.steps).toHaveLength(3);
+      expect(result.steps[2].dependsOn).toEqual(["step_1", "step_2"]);
+    });
+  });
+
+  describe("loop pattern", () => {
+    it("creates single-step loop with config", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "loop",
+          suggestedLoopConfig: { maxIterations: 3, timeBudgetMs: 60000 },
+        }),
+      });
+
+      expect(result.pattern).toBe("loop");
+      expect(result.steps).toHaveLength(1);
+      expect(result.loopConfig?.maxIterations).toBe(3);
+      expect(result.loopConfig?.timeBudgetMs).toBe(60000);
+    });
+
+    it("defaults to 5 iterations", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({ recommendedPattern: "loop" }),
+      });
+
+      expect(result.loopConfig?.maxIterations).toBe(5);
+    });
+
+    it("applies loop config overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "loop",
+          suggestedLoopConfig: { maxIterations: 3 },
+        }),
+        overrides: { loopConfig: { maxIterations: 10 } },
+      });
+
+      expect(result.loopConfig?.maxIterations).toBe(10);
+    });
+  });
+
+  describe("swarm pattern", () => {
+    it("creates mayor/workers/refinery structure", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "swarm",
+          breakdown: [
+            { title: "Worker 1", description: "Task 1" },
+            { title: "Worker 2", description: "Task 2" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("swarm");
+      // mayor + 2 workers + refinery = 4
+      expect(result.steps).toHaveLength(4);
+      expect(result.steps[0].name).toBe("Build Auth System"); // mayor
+      expect(result.steps[3].name).toBe("Refine and merge results"); // refinery
+      expect(result.swarmConfig?.workerConcurrencyLimit).toBe(2);
+    });
+
+    it("applies swarm config overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "swarm",
+          breakdown: [
+            { title: "W1", description: "T1" },
+            { title: "W2", description: "T2" },
+          ],
+          suggestedSwarmConfig: { workerConcurrencyLimit: 1 },
+        }),
+        overrides: { swarmConfig: { workerConcurrencyLimit: 2 } },
+      });
+
+      expect(result.swarmConfig?.workerConcurrencyLimit).toBe(2);
+    });
+  });
+
+  describe("pattern override", () => {
+    it("overrides AI-recommended pattern", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({ recommendedPattern: "sequence" }),
+        overrides: { pattern: "checkpoint" },
+      });
+
+      expect(result.pattern).toBe("checkpoint");
+    });
+  });
+
+  describe("step overrides", () => {
+    it("applies partial step overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse(),
+        overrides: {
+          steps: [
+            undefined,
+            { agentProfile: "code-reviewer" },
+          ] as Partial<import("../types").WorkflowStep>[],
+        },
+      });
+
+      expect(result.steps[1].agentProfile).toBe("code-reviewer");
+    });
+  });
+
+  describe("validation", () => {
+    it("throws on invalid definition", () => {
+      expect(() =>
+        buildWorkflowDefinitionFromAssist({
+          mainTask: MAIN_TASK,
+          assistResponse: makeAssistResponse({
+            recommendedPattern: "loop",
+            // Missing loopConfig
+          }),
+          overrides: { loopConfig: { maxIterations: 0 } },
+        })
+      ).toThrow("Invalid workflow definition");
+    });
+  });
+
+  describe("auto profile handling", () => {
+    it('treats "auto" suggestedProfile as undefined', () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: { ...MAIN_TASK, agentProfile: undefined },
+        assistResponse: makeAssistResponse({
+          breakdown: [
+            { title: "Step", description: "Do thing", suggestedProfile: "auto" },
+          ],
+        }),
+      });
+
+      expect(result.steps[0].agentProfile).toBeUndefined();
+      expect(result.steps[1].agentProfile).toBeUndefined();
+    });
+  });
+});

package/src/lib/workflows/assist-builder.ts

@@ -0,0 +1,248 @@
+import type { WorkflowDefinition, WorkflowStep, WorkflowPattern } from "./types";
+import type { TaskAssistResponse, TaskAssistBreakdownStep } from "@/lib/agents/runtime/task-assist-types";
+import { validateWorkflowDefinition } from "./definition-validation";
+
+interface AssistBuilderInput {
+  mainTask: {
+    title: string;
+    description: string;
+    agentProfile?: string;
+  };
+  assistResponse: TaskAssistResponse;
+  overrides?: {
+    pattern?: WorkflowPattern;
+    steps?: Partial<WorkflowStep>[];
+    loopConfig?: { maxIterations?: number; timeBudgetMs?: number };
+    swarmConfig?: { workerConcurrencyLimit?: number };
+  };
+}
+
+function stepId(index: number): string {
+  return `step_${index + 1}`;
+}
+
+function buildStep(
+  index: number,
+  name: string,
+  prompt: string,
+  options?: {
+    agentProfile?: string;
+    requiresApproval?: boolean;
+    dependsOn?: string[];
+  }
+): WorkflowStep {
+  return {
+    id: stepId(index),
+    name,
+    prompt,
+    agentProfile: options?.agentProfile,
+    requiresApproval: options?.requiresApproval,
+    dependsOn: options?.dependsOn,
+  };
+}
+
+function resolveProfile(
+  suggestedProfile: string | undefined,
+  fallbackProfile: string | undefined
+): string | undefined {
+  const profile = suggestedProfile ?? fallbackProfile;
+  if (!profile || profile === "auto") return undefined;
+  return profile;
+}
+
+function breakdownToSteps(
+  mainTask: AssistBuilderInput["mainTask"],
+  breakdown: TaskAssistBreakdownStep[],
+  pattern: WorkflowPattern
+): WorkflowStep[] {
+  const steps: WorkflowStep[] = [];
+
+  // Step 1 is always the main task
+  steps.push(
+    buildStep(0, mainTask.title, mainTask.description, {
+      agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+    })
+  );
+
+  // Remaining steps from breakdown
+  for (let i = 0; i < breakdown.length; i++) {
+    const sub = breakdown[i];
+    const dependsOn = sub.dependsOn?.map((depIdx) => stepId(depIdx));
+    steps.push(
+      buildStep(i + 1, sub.title, sub.description, {
+        agentProfile: resolveProfile(sub.suggestedProfile, undefined),
+        requiresApproval: pattern === "checkpoint" ? sub.requiresApproval : undefined,
+        dependsOn,
+      })
+    );
+  }
+
+  return steps;
+}
+
+function buildSequenceDefinition(
+  mainTask: AssistBuilderInput["mainTask"],
+  assist: TaskAssistResponse,
+  pattern: "sequence" | "planner-executor" | "checkpoint"
+): WorkflowDefinition {
+  const steps = breakdownToSteps(mainTask, assist.breakdown, pattern);
+  return { pattern, steps };
+}
+
+function buildParallelDefinition(
+  mainTask: AssistBuilderInput["mainTask"],
+  assist: TaskAssistResponse
+): WorkflowDefinition {
+  const breakdown = assist.breakdown;
+
+  // Steps with no dependsOn are branches; steps with dependsOn are synthesis
+  const hasSynthesis = breakdown.some((s) => s.dependsOn && s.dependsOn.length > 0);
+
+  const steps: WorkflowStep[] = [];
+
+  // Main task as first branch
+  steps.push(
+    buildStep(0, mainTask.title, mainTask.description, {
+      agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+    })
+  );
+
+  // Add breakdown items as branches (no dependsOn) or synthesis (with dependsOn)
+  for (let i = 0; i < breakdown.length; i++) {
+    const sub = breakdown[i];
+    const dependsOn = sub.dependsOn?.map((depIdx) => stepId(depIdx));
+    steps.push(
+      buildStep(i + 1, sub.title, sub.description, {
+        agentProfile: resolveProfile(sub.suggestedProfile, undefined),
+        dependsOn,
+      })
+    );
+  }
+
+  // Auto-generate synthesis step if none exists
+  if (!hasSynthesis) {
+    const branchIds = steps.map((s) => s.id);
+    steps.push(
+      buildStep(steps.length, "Synthesize results", "Combine and synthesize the results from all parallel branches into a coherent summary.", {
+        dependsOn: branchIds,
+      })
+    );
+  }
+
+  return { pattern: "parallel", steps };
+}
+
+function buildLoopDefinition(
+  mainTask: AssistBuilderInput["mainTask"],
+  assist: TaskAssistResponse,
+  overrides?: AssistBuilderInput["overrides"]
+): WorkflowDefinition {
+  const loopConfig = {
+    maxIterations: overrides?.loopConfig?.maxIterations
+      ?? assist.suggestedLoopConfig?.maxIterations
+      ?? 5,
+    timeBudgetMs: overrides?.loopConfig?.timeBudgetMs
+      ?? assist.suggestedLoopConfig?.timeBudgetMs,
+    agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+  };
+
+  const steps: WorkflowStep[] = [
+    buildStep(0, mainTask.title, mainTask.description, {
+      agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+    }),
+  ];
+
+  return { pattern: "loop", steps, loopConfig };
+}
+
+function buildSwarmDefinition(
+  mainTask: AssistBuilderInput["mainTask"],
+  assist: TaskAssistResponse,
+  overrides?: AssistBuilderInput["overrides"]
+): WorkflowDefinition {
+  const breakdown = assist.breakdown;
+  const steps: WorkflowStep[] = [];
+
+  // Step 1 = mayor (main task)
+  steps.push(
+    buildStep(0, mainTask.title, mainTask.description, {
+      agentProfile: resolveProfile(undefined, mainTask.agentProfile),
+    })
+  );
+
+  // Steps 2..N-1 = workers (from breakdown)
+  for (let i = 0; i < breakdown.length; i++) {
+    const sub = breakdown[i];
+    steps.push(
+      buildStep(i + 1, sub.title, sub.description, {
+        agentProfile: resolveProfile(sub.suggestedProfile, undefined),
+      })
+    );
+  }
+
+  // Step N = refinery (auto-generated)
+  steps.push(
+    buildStep(steps.length, "Refine and merge results", "Review all worker outputs, resolve conflicts, and produce a unified final result.", {})
+  );
+
+  const swarmConfig = {
+    workerConcurrencyLimit: overrides?.swarmConfig?.workerConcurrencyLimit
+      ?? assist.suggestedSwarmConfig?.workerConcurrencyLimit
+      ?? 2,
+  };
+
+  return { pattern: "swarm", steps, swarmConfig };
+}
+
+/**
+ * Convert an AI Assist response into a validated WorkflowDefinition.
+ * Pure function — no side effects.
+ */
+export function buildWorkflowDefinitionFromAssist(
+  input: AssistBuilderInput
+): WorkflowDefinition {
+  const pattern = input.overrides?.pattern ?? input.assistResponse.recommendedPattern as WorkflowPattern;
+  const { mainTask, assistResponse, overrides } = input;
+
+  let definition: WorkflowDefinition;
+
+  switch (pattern) {
+    case "sequence":
+    case "planner-executor":
+    case "checkpoint":
+      definition = buildSequenceDefinition(mainTask, assistResponse, pattern);
+      break;
+    case "parallel":
+      definition = buildParallelDefinition(mainTask, assistResponse);
+      break;
+    case "loop":
+      definition = buildLoopDefinition(mainTask, assistResponse, overrides);
+      break;
+    case "swarm":
+      definition = buildSwarmDefinition(mainTask, assistResponse, overrides);
+      break;
+    default:
+      // Fallback to sequence for unknown patterns
+      definition = buildSequenceDefinition(mainTask, assistResponse, "sequence");
+  }
+
+  // Apply step-level overrides
+  if (overrides?.steps) {
+    for (let i = 0; i < overrides.steps.length && i < definition.steps.length; i++) {
+      const stepOverride = overrides.steps[i];
+      if (stepOverride) {
+        Object.assign(definition.steps[i], stepOverride);
+      }
+    }
+  }
+
+  // Validate
+  const validationError = validateWorkflowDefinition(definition);
+  if (validationError) {
+    throw new Error(`Invalid workflow definition: ${validationError}`);
+  }
+
+  return definition;
+}
+
+export type { AssistBuilderInput };

package/src/lib/workflows/assist-session.ts

@@ -0,0 +1,78 @@
+import type { TaskAssistResponse } from "@/lib/agents/runtime/task-assist-types";
+
+const STORAGE_KEY = "stagent:workflow-from-assist";
+
+export interface WorkflowAssistState {
+  assistResult: TaskAssistResponse;
+  formState: {
+    title: string;
+    description: string;
+    projectId: string;
+    priority: string;
+    agentProfile: string;
+    assignedAgent: string;
+  };
+}
+
+export function saveAssistState(state: WorkflowAssistState): void {
+  try {
+    sessionStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+  } catch {
+    // sessionStorage may be unavailable (e.g. SSR)
+  }
+}
+
+export function loadAssistState(): WorkflowAssistState | null {
+  try {
+    const raw = sessionStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    return JSON.parse(raw) as WorkflowAssistState;
+  } catch {
+    return null;
+  }
+}
+
+export function clearAssistState(): void {
+  try {
+    sessionStorage.removeItem(STORAGE_KEY);
+  } catch {
+    // noop
+  }
+}
+
+const FORM_RESTORE_KEY = "stagent:task-form-restore";
+
+export interface TaskFormState {
+  title: string;
+  description: string;
+  projectId: string;
+  priority: string;
+  agentProfile: string;
+  assignedAgent: string;
+}
+
+export function saveTaskFormState(state: TaskFormState): void {
+  try {
+    sessionStorage.setItem(FORM_RESTORE_KEY, JSON.stringify(state));
+  } catch {
+    // noop
+  }
+}
+
+export function loadTaskFormState(): TaskFormState | null {
+  try {
+    const raw = sessionStorage.getItem(FORM_RESTORE_KEY);
+    if (!raw) return null;
+    return JSON.parse(raw) as TaskFormState;
+  } catch {
+    return null;
+  }
+}
+
+export function clearTaskFormState(): void {
+  try {
+    sessionStorage.removeItem(FORM_RESTORE_KEY);
+  } catch {
+    // noop
+  }
+}