@geminilight/mindos 0.6.29 → 0.6.31

package/app/components/renderers/workflow-yaml/WorkflowYamlRenderer.tsx

@@ -0,0 +1,126 @@
+'use client';
+
+import { useMemo, useState, useCallback, useRef } from 'react';
+import { Pencil, Play, AlertCircle, Zap } from 'lucide-react';
+import type { RendererContext } from '@/lib/renderers/registry';
+import { parseWorkflowYaml } from './parser';
+import WorkflowEditor from './WorkflowEditor';
+import WorkflowRunner from './WorkflowRunner';
+import type { WorkflowYaml } from './types';
+
+type Mode = 'edit' | 'run';
+
+export function WorkflowYamlRenderer({ filePath, content }: RendererContext) {
+  const parsed = useMemo(() => parseWorkflowYaml(content), [content]);
+  const [mode, setMode] = useState<Mode>('edit');
+  const [dirty, setDirty] = useState(false);
+
+  const [editWorkflow, setEditWorkflow] = useState<WorkflowYaml>(() => {
+    if (parsed.workflow) return structuredClone(parsed.workflow);
+    return { title: '', description: '', steps: [] };
+  });
+
+  const savedContentRef = useRef(content);
+  const latestParsed = useMemo(() => parsed.workflow ?? null, [parsed.workflow]);
+
+  const handleEditorChange = useCallback((wf: WorkflowYaml) => {
+    setEditWorkflow(wf);
+    setDirty(true);
+  }, []);
+
+  const handleSaved = useCallback(() => setDirty(false), []);
+
+  const runWorkflow = latestParsed ?? editWorkflow;
+  const canRun = runWorkflow.steps.length > 0 && !!runWorkflow.title;
+  const hasParseErrors = parsed.errors.length > 0;
+
+  const runDisabledReason = !runWorkflow.title
+    ? 'Add a title first'
+    : runWorkflow.steps.length === 0
+      ? 'Add at least one step'
+      : dirty ? 'Save changes first' : undefined;
+
+  const handleModeSwitch = (target: Mode) => {
+    if (target === 'run' && !canRun) return;
+    setMode(target);
+  };
+
+  return (
+    <div className="max-w-[720px] mx-auto py-8 px-2">
+      {/* Hero header — gives the page identity */}
+      <div className="mb-8">
+        {/* Mode tabs + step count */}
+        <div className="flex items-center justify-between mb-4">
+          <div className="flex items-center gap-1 p-0.5 rounded-lg bg-muted/50">
+            <button
+              onClick={() => handleModeSwitch('edit')}
+              className={`flex items-center gap-1.5 px-3 py-1.5 rounded-md text-xs font-medium transition-all ${
+                mode === 'edit'
+                  ? 'bg-background text-foreground shadow-sm'
+                  : 'text-muted-foreground hover:text-foreground'
+              }`}
+            >
+              <Pencil size={11} />
+              Edit
+            </button>
+            <button
+              onClick={() => handleModeSwitch('run')}
+              disabled={!canRun}
+              title={runDisabledReason}
+              className={`flex items-center gap-1.5 px-3 py-1.5 rounded-md text-xs font-medium transition-all disabled:opacity-30 disabled:cursor-not-allowed ${
+                mode === 'run'
+                  ? 'bg-background text-foreground shadow-sm'
+                  : 'text-muted-foreground hover:text-foreground'
+              }`}
+            >
+              <Play size={11} />
+              Run
+            </button>
+          </div>
+
+          {editWorkflow.steps.length > 0 && (
+            <span className="text-2xs text-muted-foreground/60 font-mono">
+              {editWorkflow.steps.length} step{editWorkflow.steps.length !== 1 ? 's' : ''}
+            </span>
+          )}
+        </div>
+
+        {/* Title */}
+        <div className="flex items-start gap-3">
+          <div className="mt-1 w-8 h-8 rounded-lg bg-[var(--amber)]/10 flex items-center justify-center shrink-0">
+            <Zap size={16} className="text-[var(--amber)]" />
+          </div>
+          <div className="min-w-0 flex-1">
+            <h1 className="text-lg font-semibold text-foreground truncate leading-tight">
+              {editWorkflow.title || 'Untitled Flow'}
+              {dirty && <span className="text-[var(--amber)] ml-1.5 text-sm" title="Unsaved changes">*</span>}
+            </h1>
+            {editWorkflow.description && (
+              <p className="text-xs text-muted-foreground mt-0.5 line-clamp-1">{editWorkflow.description}</p>
+            )}
+          </div>
+        </div>
+      </div>
+
+      {/* Parse error banner */}
+      {hasParseErrors && mode === 'edit' && (
+        <div className="mb-5 px-3.5 py-3 rounded-lg bg-[var(--error)]/8 border border-[var(--error)]/20">
+          <div className="flex items-center gap-2 mb-1.5">
+            <AlertCircle size={13} className="text-[var(--error)] shrink-0" />
+            <span className="text-xs font-medium text-[var(--error)]">Parse issues found</span>
+          </div>
+          <ul className="text-2xs text-[var(--error)]/70 pl-5 list-disc space-y-0.5">
+            {parsed.errors.slice(0, 3).map((e, i) => <li key={i}>{e}</li>)}
+          </ul>
+        </div>
+      )}
+
+      {/* Content */}
+      {mode === 'edit' ? (
+        <WorkflowEditor workflow={editWorkflow} filePath={filePath} onChange={handleEditorChange} onSaved={handleSaved} />
+      ) : (
+        <WorkflowRunner workflow={runWorkflow} filePath={filePath} />
+      )}
+    </div>
+  );
+}

package/app/components/renderers/workflow-yaml/execution.ts

@@ -0,0 +1,229 @@
+// Workflow step execution logic — fetches skills, resolves agents, constructs prompts, streams AI responses
+
+import type { WorkflowYaml, WorkflowStepRuntime } from './types';
+
+// ─── Skill Fetching ───────────────────────────────────────────────────────
+
+/** Cache skill content for the duration of a workflow run to avoid redundant fetches */
+const skillCache = new Map<string, string | null>();
+
+export function clearSkillCache() {
+  skillCache.clear();
+}
+
+/**
+ * Fetch skill content from /api/skills. Returns the full SKILL.md content,
+ * or null if the skill doesn't exist. Results are cached per skill name.
+ */
+async function fetchSkillContent(name: string, signal: AbortSignal): Promise<string | null> {
+  if (skillCache.has(name)) return skillCache.get(name)!;
+
+  try {
+    const res = await fetch('/api/skills', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'read', name }),
+      signal,
+    });
+    if (!res.ok) {
+      skillCache.set(name, null);
+      return null;
+    }
+    const data = await res.json();
+    const content = data.content as string | undefined;
+    skillCache.set(name, content ?? null);
+    return content ?? null;
+  } catch {
+    // Network error or abort — don't cache failures
+    return null;
+  }
+}
+
+/**
+ * Collect all unique skill names referenced by a step (step-level + workflow-level).
+ * Handles both legacy `skill` (singular) and new `skills` (array) fields.
+ */
+function collectSkillNames(step: WorkflowStepRuntime, workflow: WorkflowYaml): string[] {
+  const names: string[] = [];
+  // Step-level skills (new array format takes priority)
+  if (step.skills?.length) {
+    for (const s of step.skills) {
+      if (!names.includes(s)) names.push(s);
+    }
+  } else if (step.skill) {
+    names.push(step.skill);
+  }
+  // Workflow-level skills
+  for (const s of workflow.skills ?? []) {
+    if (!names.includes(s)) names.push(s);
+  }
+  return names;
+}
+
+// ─── ACP Agent Resolution ────────────────────────────────────────────────
+
+/** Resolve an agent name/id to an ACP agent selection { id, name } */
+async function resolveAcpAgent(
+  agentId: string,
+  signal: AbortSignal,
+): Promise<{ id: string; name: string } | null> {
+  try {
+    const res = await fetch(`/api/acp/registry?agent=${encodeURIComponent(agentId)}`, { signal });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (data.agent?.id) {
+      return { id: data.agent.id, name: data.agent.name || agentId };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Prompt Construction ──────────────────────────────────────────────────
+
+function buildPrompt(
+  step: WorkflowStepRuntime,
+  workflow: WorkflowYaml,
+  skillContents: Map<string, string>,
+): string {
+  const allStepsSummary = workflow.steps.map((s, i) => `${i + 1}. ${s.name}`).join('\n');
+
+  // Determine primary skill name for labeling
+  const primarySkill = step.skills?.length ? step.skills[0] : step.skill;
+
+  // Build skill context block
+  let skillBlock = '';
+  if (skillContents.size > 0) {
+    const sections: string[] = [];
+    for (const [name, content] of skillContents) {
+      const isPrimary = name === primarySkill;
+      sections.push(
+        `### ${isPrimary ? '[Primary] ' : ''}Skill: ${name}\n\n${content}`
+      );
+    }
+    skillBlock = `\n\n---\n## Skill Reference\n\nFollow the guidelines from these skills when executing this step:\n\n${sections.join('\n\n---\n\n')}`;
+  }
+
+  return `You are executing step ${step.index + 1} of a workflow: "${step.name}".
+
+Context of the full workflow "${workflow.title}":
+${allStepsSummary}
+
+Current step instructions:
+${step.prompt || '(No specific instructions — use common sense.)'}${skillBlock}
+
+Execute concisely. Provide:
+1. What you did / what the output is
+2. Any decisions made
+3. What the next step should watch out for
+
+Be specific and actionable. Format in Markdown.`;
+}
+
+// ─── Streaming Execution ──────────────────────────────────────────────────
+
+/**
+ * Execute a workflow step with AI:
+ * 1. Fetch referenced skill(s) content
+ * 2. Resolve ACP agent (if step.agent is set)
+ * 3. Build prompt with injected skill context
+ * 4. Stream response from /api/ask (routed to ACP agent if resolved)
+ */
+export async function runStepWithAI(
+  step: WorkflowStepRuntime,
+  workflow: WorkflowYaml,
+  filePath: string,
+  onChunk: (accumulated: string) => void,
+  signal: AbortSignal,
+): Promise<void> {
+  // 1. Fetch skill content
+  const skillNames = collectSkillNames(step, workflow);
+  const skillContents = new Map<string, string>();
+
+  if (skillNames.length > 0) {
+    const results = await Promise.all(
+      skillNames.map(async (name) => {
+        const content = await fetchSkillContent(name, signal);
+        return [name, content] as const;
+      })
+    );
+    for (const [name, content] of results) {
+      if (content) skillContents.set(name, content);
+    }
+  }
+
+  // 2. Resolve ACP agent
+  let selectedAcpAgent: { id: string; name: string } | null = null;
+  if (step.agent) {
+    selectedAcpAgent = await resolveAcpAgent(step.agent, signal);
+    // If agent name doesn't resolve in ACP registry, skip silently
+    // (the step will run with the default MindOS agent)
+  }
+
+  // 3. Build prompt
+  const prompt = buildPrompt(step, workflow, skillContents);
+
+  // 4. Stream from /api/ask
+  const body: Record<string, unknown> = {
+    messages: [{ role: 'user', content: prompt }],
+    currentFile: filePath,
+  };
+  if (selectedAcpAgent) {
+    body.selectedAcpAgent = selectedAcpAgent;
+  }
+
+  const res = await fetch('/api/ask', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+    signal,
+  });
+
+  if (!res.ok) throw new Error(`Request failed (HTTP ${res.status})`);
+  if (!res.body) throw new Error('No response body');
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let acc = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const raw = decoder.decode(value, { stream: true });
+    for (const line of raw.split('\n')) {
+      // SSE format: data:{"type":"text_delta","delta":"..."}
+      const sseMatch = line.match(/^data:(.+)$/);
+      if (sseMatch) {
+        try {
+          const event = JSON.parse(sseMatch[1]);
+          if (event.type === 'text_delta' && typeof event.delta === 'string') {
+            acc += event.delta;
+            onChunk(acc);
+          } else if (event.type === 'thinking_delta' && typeof event.delta === 'string') {
+            // Show agent thinking as dimmed text
+            acc += event.delta;
+            onChunk(acc);
+          } else if (event.type === 'error' && event.message) {
+            // ACP agent error — throw so WorkflowRunner shows it in step error state
+            throw new Error(event.message);
+          }
+        } catch {
+          // Not valid JSON — try legacy Vercel AI SDK format: 0:"..."
+          const legacyMatch = line.match(/^0:"((?:[^"\\]|\\.)*)"$/);
+          if (legacyMatch) {
+            acc += legacyMatch[1].replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+            onChunk(acc);
+          }
+        }
+        continue;
+      }
+      // Legacy Vercel AI SDK format (without SSE prefix)
+      const legacyMatch = line.match(/^0:"((?:[^"\\]|\\.)*)"$/);
+      if (legacyMatch) {
+        acc += legacyMatch[1].replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+        onChunk(acc);
+      }
+    }
+  }
+}

package/app/components/renderers/workflow-yaml/index.ts

@@ -0,0 +1,6 @@
+export { manifest } from './manifest';
+export { WorkflowYamlRenderer } from './WorkflowYamlRenderer';
+export { parseWorkflowYaml, validateWorkflowSchema, getStepDescription } from './parser';
+export { runStepWithAI, clearSkillCache } from './execution';
+export { serializeWorkflowYaml, generateStepId } from './serializer';
+export type { WorkflowStep, WorkflowYaml, WorkflowStepRuntime, StepStatus, ParseResult, ValidationResult } from './types';

package/app/components/renderers/workflow-yaml/manifest.ts

@@ -0,0 +1,21 @@
+import type { RendererDefinition } from '@/lib/renderers/registry';
+
+export const manifest: RendererDefinition = {
+  id: 'workflow-yaml',
+  name: 'Workflow Runner',
+  description: 'Execute step-by-step YAML workflows with Skills & Agent support.',
+  author: 'MindOS',
+  icon: '⚡',
+  tags: ['workflow', 'automation', 'steps', 'ai', 'yaml'],
+  builtin: true,
+  core: true,
+  appBuiltinFeature: true,
+  entryPath: '.mindos/workflows/',
+  match: ({ extension, filePath }) => {
+    if (extension !== 'yaml' && extension !== 'yml') return false;
+    return /\.flow\.(yaml|yml)$/i.test(filePath);
+  },
+  load: () => import('./WorkflowYamlRenderer').then(m => ({ 
+    default: m.WorkflowYamlRenderer 
+  })),
+};

package/app/components/renderers/workflow-yaml/parser.ts

@@ -0,0 +1,172 @@
+import YAML from 'js-yaml';
+import type { WorkflowYaml, ParseResult, ValidationResult, WorkflowStep } from './types';
+
+export function parseWorkflowYaml(content: string): ParseResult {
+  try {
+    const parsed = YAML.load(content, { schema: YAML.JSON_SCHEMA }) as unknown;
+    
+    if (!parsed) {
+      return {
+        workflow: null,
+        errors: ['File is empty'],
+      };
+    }
+
+    if (typeof parsed !== 'object') {
+      return {
+        workflow: null,
+        errors: ['Content is not valid YAML'],
+      };
+    }
+
+    const validation = validateWorkflowSchema(parsed);
+    if (!validation.valid) {
+      return {
+        workflow: null,
+        errors: validation.errors,
+      };
+    }
+
+    return {
+      workflow: parsed as WorkflowYaml,
+      errors: [],
+    };
+  } catch (err) {
+    return {
+      workflow: null,
+      errors: [err instanceof Error ? err.message : String(err)],
+    };
+  }
+}
+
+export function validateWorkflowSchema(obj: unknown): ValidationResult {
+  const errors: string[] = [];
+
+  if (!obj || typeof obj !== 'object') {
+    return { valid: false, errors: ['Must be a valid YAML object'] };
+  }
+
+  const w = obj as Record<string, any>;
+
+  // Validate title
+  if (!w.title || typeof w.title !== 'string' || !w.title.trim()) {
+    errors.push("Missing required field 'title' (string)");
+  }
+
+  // Validate description (optional)
+  if (w.description !== undefined && typeof w.description !== 'string') {
+    errors.push("'description' must be a string");
+  }
+
+  // Validate skills (optional)
+  if (w.skills !== undefined) {
+    if (!Array.isArray(w.skills)) {
+      errors.push("'skills' must be an array of strings");
+    } else if (!w.skills.every((s: any) => typeof s === 'string')) {
+      errors.push("'skills' must contain only strings");
+    }
+  }
+
+  // Validate tools (optional)
+  if (w.tools !== undefined) {
+    if (!Array.isArray(w.tools)) {
+      errors.push("'tools' must be an array of strings");
+    } else if (!w.tools.every((t: any) => typeof t === 'string')) {
+      errors.push("'tools' must contain only strings");
+    }
+  }
+
+  // Validate steps
+  if (!w.steps) {
+    errors.push("Missing required field 'steps' (array)");
+  } else if (!Array.isArray(w.steps)) {
+    errors.push("'steps' must be an array");
+  } else if (w.steps.length === 0) {
+    errors.push("'steps' must have at least 1 step");
+  } else {
+    const seenIds = new Set<string>();
+    w.steps.forEach((step: any, idx: number) => {
+      const stepErrors = validateStep(step, idx);
+      errors.push(...stepErrors);
+      // Check for duplicate IDs
+      const id = step?.id;
+      if (typeof id === 'string' && id.trim()) {
+        if (seenIds.has(id)) {
+          errors.push(`steps[${idx}].id: duplicate id '${id}' (each step must have a unique id)`);
+        }
+        seenIds.add(id);
+      }
+    });
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+function validateStep(step: unknown, index: number): string[] {
+  const errors: string[] = [];
+  const prefix = `steps[${index}]`;
+
+  if (!step || typeof step !== 'object') {
+    errors.push(`${prefix}: must be a valid object`);
+    return errors;
+  }
+
+  const s = step as Record<string, any>;
+
+  // Validate id
+  if (!s.id || typeof s.id !== 'string' || !s.id.trim()) {
+    errors.push(`${prefix}: missing required field 'id' (non-empty string)`);
+  } else if (!/^[a-z0-9_-]+$/.test(s.id)) {
+    errors.push(`${prefix}.id: '${s.id}' is invalid — use only lowercase letters, numbers, hyphens, underscores (e.g., 'run-tests')`);
+  }
+
+  // Validate name
+  if (!s.name || typeof s.name !== 'string' || !s.name.trim()) {
+    errors.push(`${prefix}: missing required field 'name' (non-empty string)`);
+  }
+
+  // Validate description (optional)
+  if (s.description !== undefined && typeof s.description !== 'string') {
+    errors.push(`${prefix}.description: must be a string`);
+  }
+
+  // Validate agent (optional)
+  if (s.agent !== undefined && (typeof s.agent !== 'string' || !s.agent.trim())) {
+    errors.push(`${prefix}.agent: must be a non-empty string`);
+  }
+
+  // Validate skill (optional)
+  if (s.skill !== undefined && (typeof s.skill !== 'string' || !s.skill.trim())) {
+    errors.push(`${prefix}.skill: must be a non-empty string`);
+  }
+
+  // Validate tools (optional)
+  if (s.tools !== undefined) {
+    if (!Array.isArray(s.tools)) {
+      errors.push(`${prefix}.tools: must be an array of strings`);
+    } else if (!s.tools.every((t: any) => typeof t === 'string')) {
+      errors.push(`${prefix}.tools: must contain only strings`);
+    }
+  }
+
+  // Validate prompt (required)
+  if (!s.prompt || typeof s.prompt !== 'string' || !s.prompt.trim()) {
+    errors.push(`${prefix}: missing required field 'prompt' (non-empty string)`);
+  }
+
+  // Validate timeout (optional)
+  if (s.timeout !== undefined) {
+    if (typeof s.timeout !== 'number' || s.timeout <= 0) {
+      errors.push(`${prefix}.timeout: must be a positive number (seconds)`);
+    }
+  }
+
+  return errors;
+}
+
+export function getStepDescription(step: WorkflowStep): string {
+  return step.description || step.prompt.split('\n')[0].slice(0, 100);
+}