@geminilight/mindos 0.6.29 → 0.6.30

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 } 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);
+
+  // Editor state: start from parsed workflow or a blank template
+  const [editWorkflow, setEditWorkflow] = useState<WorkflowYaml>(() => {
+    if (parsed.workflow) return structuredClone(parsed.workflow);
+    return { title: '', description: '', steps: [] };
+  });
+
+  // Track original content for dirty detection
+  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);
+  }, []);
+
+  // Runner uses latest parsed workflow (from file), not editor state
+  const runWorkflow = latestParsed ?? editWorkflow;
+  const canRun = runWorkflow.steps.length > 0 && !!runWorkflow.title;
+  const hasParseErrors = parsed.errors.length > 0;
+
+  // Explain why Run is disabled
+  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' && dirty) {
+      // Don't block, but show the tooltip
+    }
+    if (target === 'run' && !canRun) return;
+    setMode(target);
+  };
+
+  return (
+    <div className="max-w-[720px] mx-auto py-6 px-1">
+      {/* Mode switcher + title */}
+      <div className="flex items-center gap-3 mb-5">
+        <div className="flex rounded-lg border border-border overflow-hidden text-xs">
+          <button
+            onClick={() => handleModeSwitch('edit')}
+            className={`flex items-center gap-1.5 px-3.5 py-1.5 transition-colors ${
+              mode === 'edit'
+                ? 'bg-[var(--amber)] text-[var(--amber-foreground)] font-medium'
+                : 'bg-card text-muted-foreground hover:bg-muted'
+            }`}
+          >
+            <Pencil size={12} />
+            Edit
+          </button>
+          <button
+            onClick={() => handleModeSwitch('run')}
+            disabled={!canRun}
+            title={runDisabledReason}
+            className={`flex items-center gap-1.5 px-3.5 py-1.5 transition-colors disabled:opacity-40 disabled:cursor-not-allowed ${
+              mode === 'run'
+                ? 'bg-[var(--amber)] text-[var(--amber-foreground)] font-medium'
+                : 'bg-card text-muted-foreground hover:bg-muted'
+            }`}
+          >
+            <Play size={12} />
+            Run
+          </button>
+        </div>
+
+        <h1 className="text-base font-semibold text-foreground truncate flex-1">
+          {editWorkflow.title || 'New Workflow'}
+          {dirty && <span className="text-[var(--amber)] ml-1" title="Unsaved changes">*</span>}
+        </h1>
+      </div>
+
+      {/* Parse error banner */}
+      {hasParseErrors && mode === 'edit' && (
+        <div className="mb-4 px-3 py-2.5 rounded-lg bg-[var(--error)]/10 border border-[var(--error)]/30">
+          <div className="flex items-center gap-2 mb-1">
+            <AlertCircle size={13} className="text-[var(--error)] shrink-0" />
+            <span className="text-xs font-medium text-[var(--error)]">File has parse issues</span>
+          </div>
+          <ul className="text-2xs text-[var(--error)]/80 pl-5 list-disc">
+            {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,177 @@
+// Workflow step execution logic — fetches skills, 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).
+ * Step-level skill takes priority; workflow-level skills provide additional context.
+ */
+function collectSkillNames(step: WorkflowStepRuntime, workflow: WorkflowYaml): string[] {
+  const names: string[] = [];
+  if (step.skill) names.push(step.skill);
+  for (const s of workflow.skills ?? []) {
+    if (!names.includes(s)) names.push(s);
+  }
+  return names;
+}
+
+// ─── 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');
+
+  // Build skill context block
+  let skillBlock = '';
+  if (skillContents.size > 0) {
+    const sections: string[] = [];
+    for (const [name, content] of skillContents) {
+      const isPrimary = name === step.skill;
+      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. Build prompt with injected skill context
+ * 3. Stream response from /api/ask
+ */
+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. Build prompt
+  const prompt = buildPrompt(step, workflow, skillContents);
+
+  // 3. Stream from /api/ask
+  const res = await fetch('/api/ask', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      messages: [{ role: 'user', content: prompt }],
+      currentFile: filePath,
+    }),
+    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);
+          }
+        } 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);
+}