opencode-telos 1.0.0

package/src/opencode/workflows/chains.ts

@@ -0,0 +1,205 @@
+/**
+ * Workflow Chains — Definições de workflows de múltiplos steps.
+ *
+ * Cada chain é uma lista ordenada de steps.
+ * O executor (executor.ts) executa cada step sequencialmente.
+ *
+ * Consumido por: executor.ts, tools-workflow.ts
+ * Dependências: nenhuma (módulo puro de definições)
+ */
+
+export interface WorkflowStep {
+  /** Nome da tool SDD a chamar */
+  tool: string
+  /** Args estáticos ou função que gera args do resultado anterior */
+  args: Record<string, unknown> | ((prevResult: string) => Record<string, unknown>)
+  /** Se true, falha neste step para a chain inteira */
+  required: boolean
+  /** Descrição do step para logging */
+  description: string
+}
+
+export interface WorkflowChain {
+  /** Nome da chain (usado como tool name) */
+  name: string
+  /** Descrição para o LLM */
+  description: string
+  /** Parâmetros aceitos pela chain */
+  params: Array<{ name: string; type: string; description: string; required: boolean }>
+  /** Lista de steps */
+  steps: WorkflowStep[]
+}
+
+// ── Chain: New Feature ────────────────────────────────────────────
+
+export const NEW_FEATURE_CHAIN: WorkflowChain = {
+  name: "sdd.workflow_new_feature",
+  description: "Workflow completo para criar uma nova feature: enforce → build graph → validate → approve → generate code.",
+  params: [
+    { name: "briefing", type: "string", description: "Descrição da feature ou briefing do projeto", required: true },
+  ],
+  steps: [
+    {
+      tool: "sdd.enforce",
+      args: (prev) => ({ change_request: prev }),
+      required: true,
+      description: "Classificar a requisição e criar Change node",
+    },
+    {
+      tool: "sdd.build_graph",
+      args: (prev) => ({ briefing: prev }),
+      required: true,
+      description: "Construir o Knowledge Graph a partir do briefing",
+    },
+    {
+      tool: "sdd.validate",
+      args: {},
+      required: true,
+      description: "Validar integridade do grafo",
+    },
+    {
+      tool: "sdd.inspect",
+      args: {},
+      required: false,
+      description: "Revisar o que foi criado",
+    },
+  ],
+}
+
+// ── Chain: Bug Fix ────────────────────────────────────────────────
+
+export const BUG_FIX_CHAIN: WorkflowChain = {
+  name: "sdd.workflow_bug_fix",
+  description: "Workflow para correção de bug: enforce → validate → approve → complete.",
+  params: [
+    { name: "bug_description", type: "string", description: "Descrição do bug", required: true },
+  ],
+  steps: [
+    {
+      tool: "sdd.enforce",
+      args: (prev) => ({ change_request: `Bug fix: ${prev}` }),
+      required: true,
+      description: "Criar Change node para o bug fix",
+    },
+    {
+      tool: "sdd.validate",
+      args: {},
+      required: true,
+      description: "Validar estado atual do grafo",
+    },
+  ],
+}
+
+// ── Chain: Hotfix ─────────────────────────────────────────────────
+
+export const HOTFIX_CHAIN: WorkflowChain = {
+  name: "sdd.workflow_hotfix",
+  description: "Workflow de emergência: hotfix sem enforcement → documentar retroativamente.",
+  params: [
+    { name: "emergency_description", type: "string", description: "Descrição da emergência", required: true },
+  ],
+  steps: [
+    {
+      tool: "sdd.hotfix",
+      args: (prev) => ({ description: prev }),
+      required: true,
+      description: "Aplicar hotfix e documentar retroativamente",
+    },
+    {
+      tool: "sdd.validate",
+      args: {},
+      required: false,
+      description: "Validar grafo após hotfix",
+    },
+  ],
+}
+
+// ── Chain: Refactoring ────────────────────────────────────────────
+
+export const REFACTORING_CHAIN: WorkflowChain = {
+  name: "sdd.workflow_refactor",
+  description: "Workflow de refactoring: enforce → validate → analyze impact → complete.",
+  params: [
+    { name: "refactoring_scope", type: "string", description: "Escopo do refactoring", required: true },
+  ],
+  steps: [
+    {
+      tool: "sdd.enforce",
+      args: (prev) => ({ change_request: `Refactoring: ${prev}` }),
+      required: true,
+      description: "Classificar refactoring e criar Change node",
+    },
+    {
+      tool: "sdd.validate",
+      args: {},
+      required: true,
+      description: "Validar grafo antes do refactoring",
+    },
+    {
+      tool: "sdd.inspect",
+      args: {},
+      required: false,
+      description: "Revisar estado atual",
+    },
+  ],
+}
+
+// ── Chain: Full Cycle ─────────────────────────────────────────────
+
+export const FULL_CYCLE_CHAIN: WorkflowChain = {
+  name: "sdd.workflow_full_cycle",
+  description: "Ciclo SDD completo: enforce → validate → generate code → detect drift → complete.",
+  params: [
+    { name: "change_request", type: "string", description: "Descrição da mudança", required: true },
+  ],
+  steps: [
+    {
+      tool: "sdd.enforce",
+      args: (prev) => ({ change_request: prev }),
+      required: true,
+      description: "Classificar e criar Change node",
+    },
+    {
+      tool: "sdd.validate",
+      args: {},
+      required: true,
+      description: "Validar grafo",
+    },
+    {
+      tool: "sdd.generate_code",
+      args: {},
+      required: true,
+      description: "Gerar código a partir da spec",
+    },
+    {
+      tool: "sdd.detect_drift",
+      args: {},
+      required: false,
+      description: "Verificar drift specification vs code",
+    },
+  ],
+}
+
+// ── Todas as chains ───────────────────────────────────────────────
+
+export const ALL_CHAINS: WorkflowChain[] = [
+  NEW_FEATURE_CHAIN,
+  BUG_FIX_CHAIN,
+  HOTFIX_CHAIN,
+  REFACTORING_CHAIN,
+  FULL_CYCLE_CHAIN,
+]
+
+/**
+ * Obtém uma chain pelo nome.
+ */
+export function getChainByName(name: string): WorkflowChain | undefined {
+  return ALL_CHAINS.find(c => c.name === name)
+}
+
+/**
+ * Lista todas as chains disponíveis (nomes + descriptions).
+ */
+export function listChainNames(): Array<{ name: string; description: string }> {
+  return ALL_CHAINS.map(c => ({ name: c.name, description: c.description }))
+}

package/src/opencode/workflows/executor.ts

@@ -0,0 +1,172 @@
+/**
+ * Workflow Executor — Executa workflow chains step by step.
+ *
+ * Cada step é executado sequencialmente.
+ * Se um step required falha, a chain para e faz rollback.
+ *
+ * Consumido por: tools-workflow.ts
+ * Dependências: chains.ts
+ */
+
+import type { WorkflowChain, WorkflowStep } from "./chains.js"
+
+export interface StepResult {
+  stepIndex: number
+  tool: string
+  description: string
+  success: boolean
+  result: string
+  timestamp: string
+}
+
+export interface ChainExecutionResult {
+  chainName: string
+  success: boolean
+  steps: StepResult[]
+  finalResult: string
+  totalTimeMs: number
+  /** Steps completados antes da falha (para rollback) */
+  completedSteps: number
+}
+
+/**
+ * Tipo da função que executa uma tool SDD.
+ * Recebe (toolName, args) e retorna a string de resultado.
+ */
+export type ToolExecutor = (toolName: string, args: Record<string, unknown>) => Promise<string>
+
+/**
+ * Executa uma workflow chain.
+ *
+ * @param chain - A chain a executar
+ * @param initialParams - Parâmetros iniciais da chain
+ * @param executeTool - Função que executa uma tool SDD
+ * @returns Resultado da execução
+ */
+export async function executeChain(
+  chain: WorkflowChain,
+  initialParams: Record<string, unknown>,
+  executeTool: ToolExecutor,
+): Promise<ChainExecutionResult> {
+  const startTime = Date.now()
+  const steps: StepResult[] = []
+  let prevResult = JSON.stringify(initialParams)
+  let completedSteps = 0
+
+  for (let i = 0; i < chain.steps.length; i++) {
+    const step = chain.steps[i]
+    const args = typeof step.args === "function"
+      ? step.args(prevResult)
+      : step.args
+
+    try {
+      const result = await executeTool(step.tool, args)
+      const stepResult: StepResult = {
+        stepIndex: i,
+        tool: step.tool,
+        description: step.description,
+        success: true,
+        result,
+        timestamp: new Date().toISOString(),
+      }
+      steps.push(stepResult)
+      prevResult = result
+      completedSteps++
+
+      // Se o resultado indica falha (contém "BLOCKED" ou "Error")
+      if (result.includes("BLOCKED") || result.startsWith("Error:")) {
+        if (step.required) {
+          return {
+            chainName: chain.name,
+            success: false,
+            steps,
+            finalResult: `Step ${i + 1} failed: ${result}`,
+            totalTimeMs: Date.now() - startTime,
+            completedSteps,
+          }
+        }
+      }
+    } catch (error) {
+      const stepResult: StepResult = {
+        stepIndex: i,
+        tool: step.tool,
+        description: step.description,
+        success: false,
+        result: error instanceof Error ? error.message : String(error),
+        timestamp: new Date().toISOString(),
+      }
+      steps.push(stepResult)
+
+      if (step.required) {
+        return {
+          chainName: chain.name,
+          success: false,
+          steps,
+          finalResult: `Step ${i + 1} (${step.description}) failed: ${stepResult.result}`,
+          totalTimeMs: Date.now() - startTime,
+          completedSteps,
+        }
+      }
+    }
+  }
+
+  return {
+    chainName: chain.name,
+    success: true,
+    steps,
+    finalResult: prevResult,
+    totalTimeMs: Date.now() - startTime,
+    completedSteps,
+  }
+}
+
+/**
+ * Formata o resultado de uma execução de chain para exibição.
+ */
+export function formatChainResult(result: ChainExecutionResult): string {
+  const lines: string[] = []
+
+  const statusIcon = result.success ? "✅" : "❌"
+  lines.push(`## ${statusIcon} Workflow: ${result.chainName}\n`)
+  lines.push(`**Tempo:** ${result.totalTimeMs}ms`)
+  lines.push(`**Steps:** ${result.completedSteps}/${result.steps.length}\n`)
+
+  // Steps
+  for (const step of result.steps) {
+    const icon = step.success ? "✅" : "❌"
+    lines.push(`### ${icon} Step ${step.stepIndex + 1}: ${step.description}`)
+    lines.push(`Tool: \`${step.tool}\``)
+    if (!step.success) {
+      lines.push(`Erro: ${step.result}`)
+    }
+    lines.push("")
+  }
+
+  // Resultado final
+  if (result.success) {
+    lines.push("### Resultado Final")
+    lines.push(result.finalResult)
+  } else {
+    lines.push("### Falha na Chain")
+    lines.push(result.finalResult)
+  }
+
+  return lines.join("\n")
+}
+
+/**
+ * Rollback: desfaz os steps completados.
+ * Nota: Na prática, o rollback é feito via snapshots do SDD.
+ * Esta função apenas informa o que precisa ser desfeito.
+ */
+export function getRollbackPlan(result: ChainExecutionResult): string[] {
+  const plan: string[] = []
+
+  for (const step of result.steps) {
+    if (step.success) {
+      plan.push(`Reverter step ${step.stepIndex + 1}: ${step.description} (${step.tool})`)
+    }
+  }
+
+  return plan
+}

package/src/opencode/workflows/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Workflows Module — Barrel export.
+ *
+ * Exporta todas as funções públicas do módulo de workflows.
+ * Consumido por: tools.ts
+ */
+
+// Chains
+export { ALL_CHAINS, getChainByName, listChainNames } from "./chains.js"
+export type { WorkflowChain, WorkflowStep } from "./chains.js"
+
+// Executor
+export { executeChain, formatChainResult, getRollbackPlan } from "./executor.js"
+export type { ChainExecutionResult, StepResult, ToolExecutor } from "./executor.js"
+
+// Types
+export { DEFAULT_EXECUTOR_CONFIG } from "./types.js"
+export type { ChainStatus, ChainExecutionLog, ExecutorConfig } from "./types.js"
+
+// Tools
+export { createWorkflowTools, listWorkflowTools } from "./tools-workflow.js"

package/src/opencode/workflows/tools-workflow.ts

@@ -0,0 +1,91 @@
+/**
+ * Workflow Tools — Tool definitions para workflow chains.
+ *
+ * Cada tool chain é uma tool SDD que o LLM pode chamar diretamente.
+ * Internamente, executa a chain de steps usando o executor.
+ *
+ * Consumido por: createSddTools() em tools.ts
+ * Dependências: chains.ts, executor.ts
+ */
+
+import { tool, type ToolDefinition } from "@opencode-ai/plugin"
+import { ALL_CHAINS, type WorkflowChain } from "./chains.js"
+import { executeChain, formatChainResult, type ToolExecutor } from "./executor.js"
+
+/**
+ * Cria uma tool definition para uma workflow chain.
+ */
+function createChainTool(chain: WorkflowChain): ToolDefinition {
+  // Build args schema from chain params
+  const argsSchema: Record<string, any> = {}
+  for (const param of chain.params) {
+    if (param.type === "string") {
+      argsSchema[param.name] = tool.schema.string().describe(param.description)
+    } else if (param.type === "number") {
+      argsSchema[param.name] = tool.schema.number().describe(param.description)
+    } else if (param.type === "boolean") {
+      argsSchema[param.name] = tool.schema.boolean().describe(param.description)
+    }
+  }
+
+  return tool({
+    description: chain.description,
+    args: argsSchema,
+    async execute(args, ctx) {
+      // Construir params iniciais
+      const params: Record<string, unknown> = {}
+      for (const param of chain.params) {
+        if (args[param.name] !== undefined) {
+          params[param.name] = args[param.name]
+        }
+      }
+
+      // Tool executor: chama as tools SDD diretamente
+      const executeTool: ToolExecutor = async (toolName, toolArgs) => {
+        // Import dinâmico para evitar circular dependencies
+        const { createSddTools } = await import("../tools.js")
+        const tools = createSddTools()
+        const sddTool = tools[toolName]
+
+        if (!sddTool) {
+          return `Error: Tool ${toolName} not found`
+        }
+
+        const result = await sddTool.execute(toolArgs as any, ctx)
+        // ToolResult pode ser string ou objeto com output
+        if (typeof result === "string") return result
+        if (result && typeof result === "object" && "output" in result) return result.output
+        return JSON.stringify(result)
+      }
+
+      // Executar chain
+      const result = await executeChain(chain, params, executeTool)
+      return formatChainResult(result)
+    },
+  })
+}
+
+/**
+ * Cria todas as tools de workflow chains.
+ * Retorna um Record compatível com createSddTools().
+ */
+export function createWorkflowTools(): Record<string, ToolDefinition> {
+  const tools: Record<string, ToolDefinition> = {}
+
+  for (const chain of ALL_CHAINS) {
+    tools[chain.name] = createChainTool(chain)
+  }
+
+  return tools
+}
+
+/**
+ * Lista todas as workflow tools disponíveis.
+ */
+export function listWorkflowTools(): Array<{ name: string; description: string; params: string[] }> {
+  return ALL_CHAINS.map(chain => ({
+    name: chain.name,
+    description: chain.description,
+    params: chain.params.map(p => `${p.name}: ${p.type}${p.required ? " (required)" : ""}`),
+  }))
+}

package/src/opencode/workflows/types.ts

@@ -0,0 +1,42 @@
+/**
+ * Workflow Types — Tipos compartilhados para o módulo de workflows.
+ *
+ * Consumido por: chains.ts, executor.ts, tools-workflow.ts
+ */
+
+import type { WorkflowChain } from "./chains.js"
+import type { ChainExecutionResult } from "./executor.js"
+
+/** Status de uma execução de chain */
+export type ChainStatus = "pending" | "running" | "completed" | "failed" | "rolled_back"
+
+/** Registro de uma execução de chain (para auditoria) */
+export interface ChainExecutionLog {
+  id: string
+  chainName: string
+  status: ChainStatus
+  startedAt: string
+  completedAt?: string
+  result?: ChainExecutionResult
+  params: Record<string, unknown>
+}
+
+/** Configuração do executor */
+export interface ExecutorConfig {
+  /** Timeout máximo por step (ms) */
+  stepTimeoutMs: number
+  /** Timeout máximo da chain inteira (ms) */
+  chainTimeoutMs: number
+  /** Se true, faz snapshot antes de cada step */
+  snapshotBeforeStep: boolean
+  /** Se true, faz rollback automático em falha */
+  autoRollback: boolean
+}
+
+/** Configuração padrão */
+export const DEFAULT_EXECUTOR_CONFIG: ExecutorConfig = {
+  stepTimeoutMs: 30_000,
+  chainTimeoutMs: 120_000,
+  snapshotBeforeStep: true,
+  autoRollback: true,
+}