elanous 0.2.20 → 0.2.22

package/src/graph-runner/runner.ts

@@ -20,6 +20,7 @@ import { parseGraphTemplateYaml, type GraphEdgeSpec, type GraphNodeSpec, type Gr
 import { createGraphVariant, type GraphVariantPlan } from '../self-implement/graph-variant.js';
 import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
 import { executeBashNode } from '../workflow-runtime/nodes/bash.js';
+import { interpolate } from '../workflow-runtime/variables.js';
 import type { BashNode, NodeExecContext, WorkflowDeps } from '../workflow-runtime/types.js';
 
 type BashRun = WorkflowDeps['runBash'];
@@ -59,6 +60,8 @@ export interface GraphRunState {
 
 export interface GraphRunOptions {
   input?: unknown;
+  /** Bytes already checked by the tick gate, used for a current-graph start or legacy resume. */
+  graphSource?: string;
   dryRun?: boolean;
   variant?: { goal: string; plan: GraphVariantPlan };
   runId?: string;
@@ -72,7 +75,7 @@ export interface GraphRunOptions {
    * its own universe and lands in the tree-derived test universe while the run ledger is prod.
    */
   pinChildUniverse?: boolean;
-  deps?: { root?: string; runBash?: BashRun; log?: (event: string, data: Record<string, unknown>) => void; processStartMs?: (pid: number) => number | null; growthProposer?: GrowthProposer; growthLLM?: (prompt: string) => Promise<string>; classifyGrowthRecipe?: (node: GraphNodeSpec, resolved: { command?: string; approval?: string }) => GrowthRecipeEffect; growthDecision?: GrowthDecisionDeps & { list?: (filters: { status: 'all' }) => DecisionEntry[] } };
+  deps?: { root?: string; runBash?: BashRun; callLLM?: (prompt: string) => Promise<string>; log?: (event: string, data: Record<string, unknown>) => void; beforeNode?: () => void; processStartMs?: (pid: number) => number | null; growthProposer?: GrowthProposer; growthLLM?: (prompt: string) => Promise<string>; classifyGrowthRecipe?: (node: GraphNodeSpec, resolved: { command?: string; approval?: string }) => GrowthRecipeEffect; growthDecision?: GrowthDecisionDeps & { list?: (filters: { status: 'all' }) => DecisionEntry[] } };
 }
 
 function safeSegment(value: string): string {
@@ -83,24 +86,29 @@ function safeSegment(value: string): string {
 }
 
 type CommandRecipe = { command: string; dry_run_command?: string; timeout_ms?: number };
-type Recipe = CommandRecipe | ({ approval: string } & Partial<CommandRecipe>);
+type PromptRecipe = { prompt: string };
+type Recipe = CommandRecipe | PromptRecipe | ({ approval: string } & Partial<CommandRecipe>);
 
 /** 접두 없는 recipe 가 카탈로그 역할이고, 그래프 옆 recipes.yaml 에 같은 키의 `{ command }` 가 있을 때만 cmd 처럼 실행한다. */
 function roleCommand(recipe: string, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): CommandRecipe | undefined {
   if (!recipe || recipe === 'none' || recipe.includes(':') || !catalogRoles.has(recipe)) return undefined;
   const entry = recipes[recipe];
   // An entry that carries an approval only runs through `approval:` — never as a bare command.
-  return entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: entry.command,
+  return entry && 'command' in entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: entry.command,
     ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
     ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } : undefined;
 }
 
-function resolveNodeRecipe(node: GraphNodeSpec, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): { command?: CommandRecipe; approval?: { approval: string } } {
+function resolveNodeRecipe(node: GraphNodeSpec, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): { command?: CommandRecipe; prompt?: PromptRecipe; approval?: { approval: string } } {
   if (node.recipe === 'none') return {};
+  if (node.kind === 'prompt' && node.recipe.startsWith('prompt:')) {
+    const entry = recipes[node.recipe.slice('prompt:'.length)];
+    return entry && 'prompt' in entry ? { prompt: entry } : {};
+  }
   if (node.recipe.startsWith('cmd:')) {
     const id = node.recipe.slice(4);
     const entry = recipes[id];
-    return entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: { command: entry.command,
+    return entry && 'command' in entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: { command: entry.command,
       ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
       ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } } : {};
   }
@@ -133,7 +141,10 @@ function recipesFor(path: string, recipeSource: string): Record<string, Recipe>
   for (const [id, raw] of Object.entries(parsed)) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error(`invalid recipe: ${id}`);
     const item = raw as Record<string, unknown>;
-    if (Object.hasOwn(item, 'approval')) {
+    if (Object.hasOwn(item, 'prompt')) {
+      if (typeof item.prompt !== 'string' || !item.prompt.trim() || Object.keys(item).some(key => key !== 'prompt')) throw new Error(`invalid recipe: ${id}`);
+      recipes[id] = { prompt: item.prompt };
+    } else if (Object.hasOwn(item, 'approval')) {
       if (typeof item.approval !== 'string' || !item.approval.trim() ||
         (item.command !== undefined && (typeof item.command !== 'string' || !item.command.trim())) ||
         (item.timeout_ms !== undefined && (!Number.isSafeInteger(item.timeout_ms) || (item.timeout_ms as number) <= 0)) ||
@@ -382,7 +393,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     ? listGraphRuns(root).runs.filter((run) => run.runId === options.resumeRunId && run.graphPath === resolve(path)) : [];
   if (matchingRuns.length > 1) throw new Error(`ambiguous run id: ${options.resumeRunId}`);
   const currentSource = options.resumeRunId && (options.resumeGraphId || matchingRuns.length) && !options.useCurrentGraph
-    ? undefined : readFileSync(path, 'utf8');
+    ? undefined : options.graphSource ?? readFileSync(path, 'utf8');
   const currentHeader: unknown = options.resumeRunId && !options.resumeGraphId && !matchingRuns.length ? parseYaml(currentSource!) : undefined;
   const resumeGraphId = options.resumeGraphId ?? matchingRuns[0]?.graphId ?? (currentHeader && typeof currentHeader === 'object' && !Array.isArray(currentHeader)
     ? (currentHeader as Record<string, unknown>).graph_id : undefined);
@@ -393,7 +404,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   }
   const snapshotDir = saved ? `${saved.statePath}.graph` : undefined;
   const graphMode: 'snapshot' | 'current' = snapshotDir && saved?.graphSnapshot && !options.useCurrentGraph ? 'snapshot' : 'current';
-  const source = graphMode === 'snapshot' ? readFileSync(join(snapshotDir!, 'graph.yaml'), 'utf8') : currentSource ?? readFileSync(path, 'utf8');
+  const source = graphMode === 'snapshot' ? readFileSync(join(snapshotDir!, 'graph.yaml'), 'utf8') : currentSource ?? options.graphSource ?? readFileSync(path, 'utf8');
   // The shared YAML parser requires a recipe string. A command-less node in
   // this runner is represented internally as `none`, without changing that parser.
   const raw: unknown = parseYaml(source);
@@ -451,7 +462,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   for (const node of graph.nodes) {
     if (node.recipe === 'none') continue;
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
-    if (!resolved.command && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
+    if (!resolved.command && !resolved.prompt && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
   }
   const graphId = safeSegment(graph.graphId);
   if (saved && graphId !== saved.graphId) {
@@ -625,6 +636,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     writeFileSync(join(`${statePath}.graph`, 'recipes.yaml'), recipeSource, { flag: 'wx' });
   }
   while (current !== undefined) {
+    options.deps?.beforeNode?.();
     const node = graph.nodes.find((n) => n.nodeId === current);
     if (!node) throw new Error(`undeclared node: ${current}`);
     const resumingPending = state.pending?.nodeId === current;
@@ -643,6 +655,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     }
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
     const command = resolved.command;
+    const prompt = resolved.prompt;
     const approval = resolved.approval ? { approval: approvalMessage(resolved.approval.approval, state.input) } : undefined;
     if (resumingPending && (!approval || approval.approval !== state.pending?.message)) {
       throw new Error(`pending approval no longer matches graph: ${current}`);
@@ -739,6 +752,25 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       error = result.error ? redactCredentials(result.error) : undefined;
       state.executed++;
     }
+    if (prompt && !state.dryRun && !resumingCompleted) {
+      const outputs: Record<string, { ok: boolean; output: unknown; durationMs: number }> = Object.create(null);
+      for (const previous of state.nodes) outputs[previous.nodeId] = { ok: previous.ok, output: lastJsonObject(previous.output) ?? previous.output ?? null, durationMs: 0 };
+      try {
+        const text = interpolate(prompt.prompt, {
+          arguments: typeof state.input === 'string' ? state.input : state.input === undefined ? '' : JSON.stringify(state.input),
+          artifactsDir: dirname(statePath), outputs,
+        });
+        if (text.missing.length) throw new Error(`missing prompt reference: ${text.missing.join(', ')}`);
+        // The LLM is injected only; production wiring to a provider is a follow-up slice.
+        if (!options.deps?.callLLM) throw new Error('prompt node requires an injected LLM (deps.callLLM)');
+        output = await options.deps.callLLM(text.text);
+        ok = true;
+      } catch (cause) {
+        ok = false;
+        error = cause instanceof Error ? cause.message : String(cause);
+      }
+      state.executed++;
+    }
     const seconds = Number(((performance.now() - startedAt) / 1000).toFixed(2));
     // A wall clock stepped back mid-node must not record an end before the start.
     const nodeEndedAt = new Date(Math.max(Date.now(), Date.parse(nodeStartedAt))).toISOString();
@@ -753,7 +785,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       if (approval && !state.dryRun && !command) {
         output = JSON.stringify({ outcome: ok ? 'approved' : 'rejected', ...(state.pending?.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending?.decidedAt ?? null });
       }
-      state.nodes.push({ nodeId: current, ok, exit, executed: !!command && (!state.dryRun || !!command.dry_run_command), ...((command || approval) && (!state.dryRun || !!command?.dry_run_command) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
+      state.nodes.push({ nodeId: current, ok, exit, executed: (!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun), ...((command || prompt || approval) && (!state.dryRun || !!command?.dry_run_command) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
         startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
     }
@@ -761,7 +793,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       delete state.pending;
       delete state.approvalSourceHash;
     }
-    const reported = command && (!state.dryRun || command.dry_run_command) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
+    const reported = (prompt && !state.dryRun) || (command && (!state.dryRun || command.dry_run_command)) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
     const namedOutcome = typeof reported === 'string' ? reported : undefined;
     console.error(`[graph] ${current} ${ok ? 'ok' : 'fail'} (${seconds.toFixed(2)}s)`);
     debug.log('graph.run', 'node', { graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds, exit });

package/src/graph-unify/wf-to-graph.ts

@@ -0,0 +1,79 @@
+import { topoSort } from '../workflow-runtime/schema.js';
+import type { DagNode, WorkflowDefinition } from '../workflow-runtime/types.js';
+import type { GraphEdgeSpec, GraphNodeSpec, GraphTemplateSpec } from '../self-implement/graph-yaml.js';
+import { WORKFLOW_CORE_KINDS } from '../graph-kinds/registry.js';
+
+/** In-memory graph projection. The compatibility executor dispatches these
+ * workflow recipes; graph-runner cannot execute all workflow node variants yet. */
+export interface WorkflowGraph {
+  readonly template: GraphTemplateSpec;
+  readonly recipes: Readonly<Record<string, DagNode>>;
+}
+
+export type WorkflowGraphResult =
+  | { readonly ok: true; readonly graph: WorkflowGraph }
+  | { readonly ok: false; readonly reason: string };
+
+/** Project a validated workflow without changing its YAML or executing any work.
+ * Reject constructs whose graph projection would silently change DAG semantics. */
+export function workflowToGraph(workflow: WorkflowDefinition): WorkflowGraphResult {
+  if ((workflow.concurrency ?? 1) !== 1) return { ok: false, reason: 'concurrency > 1' };
+  if (!workflow.nodes.length) return { ok: false, reason: 'empty workflow' };
+  if (workflow.nodes.some(node => node.on_error)) {
+    return { ok: false, reason: 'error routing' };
+  }
+  let order: string[];
+  try { order = topoSort(workflow.nodes); }
+  catch (error) { return { ok: false, reason: String(error) }; }
+  if (order.length !== workflow.nodes.length || new Set(order).size !== order.length) {
+    return { ok: false, reason: 'invalid topology' };
+  }
+  const byId = new Map(workflow.nodes.map(node => [node.id, node] as const));
+  const recipes: Record<string, DagNode> = Object.create(null);
+  const nodes: GraphNodeSpec[] = [];
+  for (const id of order) {
+    const node = byId.get(id)!;
+    const kind = typeof node.kind === 'string' ? node.kind
+      : WORKFLOW_CORE_KINDS.find(key => key !== 'subworkflow' && key in node);
+    if (!kind) {
+      return { ok: false, reason: `unknown node variant: ${id}` };
+    }
+    recipes[id] = node;
+    nodes.push({ nodeId: id, kind, recipe: `workflow:${id}`, maxVisits: 1 });
+  }
+  // A single cursor visits each node exactly once in the same stable topological
+  // order as the serial workflow executor. Preserve original dependencies and
+  // conditions in recipes; do not mistake a when expression for a graph outcome.
+  const edges: GraphEdgeSpec[] = order.slice(1).map((id, index) => ({ from: order[index]!, to: id }));
+  const template: GraphTemplateSpec = {
+    graphId: workflow.name, version: 1, entryNode: order[0]!, terminalNodes: [order.at(-1)!],
+    nodes, edges,
+  };
+  return { ok: true, graph: { template, recipes } };
+}
+
+/** The workflow compatibility cursor follows the projected graph edges, not
+ * the source DAG. The WF event adapter remains the owner of node dispatch. */
+export function walkWorkflowGraph(graph: WorkflowGraph): string[] {
+  const order: string[] = [];
+  const visited = new Set<string>();
+  let current: string | undefined = graph.template.entryNode;
+  while (current !== undefined) {
+    const spec = graph.template.nodes.find(node => node.nodeId === current);
+    if (visited.has(current) || !spec || spec.recipe !== `workflow:${current}` || spec.maxVisits !== 1
+      || !Object.hasOwn(graph.recipes, current)) throw new Error(`invalid workflow graph cursor: ${current}`);
+    const recipe = graph.recipes[current]!;
+    const kind = typeof recipe.kind === 'string' ? recipe.kind
+      : WORKFLOW_CORE_KINDS.find(key => key !== 'subworkflow' && key in recipe);
+    if (recipe.id !== current || kind !== spec.kind) throw new Error(`invalid workflow graph recipe: ${current}`);
+    visited.add(current);
+    order.push(current);
+    const outgoing: GraphEdgeSpec[] = graph.template.edges.filter(edge => edge.from === current);
+    if (outgoing.length > 1 || outgoing.some(edge => edge.to === undefined)) throw new Error(`invalid workflow graph edge: ${current}`);
+    current = outgoing[0]?.to;
+  }
+  if (order.length !== graph.template.nodes.length || !graph.template.terminalNodes.includes(order.at(-1)!)) {
+    throw new Error('incomplete workflow graph path');
+  }
+  return order;
+}

package/src/graph-wizard/archetypes.ts

@@ -0,0 +1,88 @@
+/**
+ * 마법사 «원형» — 사람이 말로 자주 시키는 일의 뼈대 셋. graphs/** 의 운영 템플릿(개발·출시 루프)은
+ * «모아서 요약해 보내기» 같은 말과 낱말이 안 겹쳐 엉뚱한 기반(lecture-note)을 골랐다(10-08 라이브 실측).
+ * 원형은 기반 후보 «맨 앞»에 서고, 키워드가 겹치는 만큼 점수를 얻는다.
+ */
+export interface WizardArchetype { id: string; description: string; keywords: string[]; text: string }
+
+export const WIZARD_ARCHETYPES: readonly WizardArchetype[] = [
+  {
+    id: 'wizard-collect-summarize-send',
+    description: '모아서 요약해 보내기 — 검색·수집 → 요약 → 텔레그램/알림 발송 (브리핑·다이제스트·동향)',
+    keywords: ['뉴스', '모아', '수집', '검색', '찾아', '요약', '정리', '보내', '알려', '텔레그램', '브리핑', '동향', '소식', 'news', 'digest', 'summary'],
+    text: `graph_id: wizard-collect-summarize-send
+loop:
+  title: 모아서 요약해 보내기
+  description: 검색으로 모은 내용을 요약해 텔레그램으로 보낸다
+  trigger:
+    cron: "0 8 * * *"
+version: 1
+entry_node: collect
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: collect, kind: agent, recipe: 'cmd:collect', max_visits: 1 }  # 수집 | web-search | 검색어
+  - { node_id: summarize, kind: agent, recipe: 'cmd:summarize', max_visits: 1 }  # 요약 | summarize | 핵심 5줄 한국어
+  - { node_id: send, kind: agent, recipe: 'cmd:send', max_visits: 1 }  # 텔레그램 발송 | telegram-send
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: collect, on: outcome, map: { ok: summarize, fail: failed } }
+  - { from: summarize, on: outcome, map: { ok: send, fail: failed } }
+  - { from: send, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+  {
+    id: 'wizard-review-merge',
+    description: 'PR 리뷰 후 머지 — 리뷰 → must-fix 없으면 승인 뒤 머지 (있으면 멈추고 알림)',
+    keywords: ['pr', '리뷰', '머지', '병합', '풀리퀘', 'must', 'fix', 'review', 'merge'],
+    text: `graph_id: wizard-review-merge
+loop:
+  title: PR 리뷰 후 머지
+  description: PR 을 리뷰하고 must-fix 가 없으면 머지한다
+  trigger:
+    events: [pr-opened]
+version: 1
+entry_node: review
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: review, kind: judge, recipe: 'cmd:review', max_visits: 1 }  # PR 리뷰 | gh-pr-review
+  - { node_id: approve-merge, kind: hitl, recipe: 'approval:approve-merge', max_visits: 1 }  # 머지 승인 | approval
+  - { node_id: merge, kind: git, recipe: 'cmd:merge', max_visits: 1 }  # PR 머지 | gh-pr-merge
+  - { node_id: notify, kind: agent, recipe: 'cmd:notify', max_visits: 1 }  # must-fix 알림 | notify-me | PR 에 must-fix 가 있어 머지하지 않았다
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: review, on: outcome, map: { ok: approve-merge, must-fix: notify, fail: failed } }
+  - { from: approve-merge, on: outcome, map: { ok: merge, fail: failed } }
+  - { from: merge, on: outcome, map: { ok: done, fail: failed } }
+  - { from: notify, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+  {
+    id: 'wizard-research-approve-publish',
+    description: '조사해 정리하고 승인 뒤 게시 — 조사 → 표/초안 정리 → 사람 승인 → 게시',
+    keywords: ['조사', '가격', '경쟁', '표', '정리', '승인', '올려', '게시', '노션', '초안', '블로그', '보고서'],
+    text: `graph_id: wizard-research-approve-publish
+loop:
+  title: 조사해 정리하고 승인 뒤 게시
+  description: 조사한 내용을 표로 정리하고 사람 승인 뒤 게시한다
+  trigger:
+    events: [manual]
+version: 1
+entry_node: research
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: research, kind: agent, recipe: 'cmd:research', max_visits: 1 }  # 조사 | web-search | 조사 주제
+  - { node_id: tabulate, kind: agent, recipe: 'cmd:tabulate', max_visits: 1 }  # 표로 정리 | llm | 결과를 마크다운 표로 정리
+  - { node_id: approve, kind: hitl, recipe: 'approval:approve', max_visits: 1 }  # 게시 승인 | approval
+  - { node_id: publish, kind: agent, recipe: 'cmd:publish', max_visits: 1 }  # 게시 | custom | 게시처에 올리기
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: research, on: outcome, map: { ok: tabulate, fail: failed } }
+  - { from: tabulate, on: outcome, map: { ok: approve, fail: failed } }
+  - { from: approve, on: outcome, map: { ok: publish, fail: failed } }
+  - { from: publish, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+];