opencode-telos 1.0.0

package/src/sdd/knowledge/transfer.ts

@@ -0,0 +1,140 @@
+import type { KnowledgeGraph } from '../domain/types.js'
+
+export interface KnowledgeTransferData {
+  architectural_decisions: Array<{
+    title: string
+    decision: string
+    context: string
+  }>
+  key_patterns: string[]
+  common_issues: string[]
+  critical_files: string[]
+}
+
+export interface KnowledgeTransferOptions {
+  /** Only include decisions with these IDs. */
+  focusDecisions?: string[]
+  /** Max items per category (default: unlimited). */
+  maxItems?: number
+  /** Only include these categories: 'decisions' | 'patterns' | 'issues' | 'files' | 'all'. */
+  focusAreas?: 'decisions' | 'patterns' | 'issues' | 'files' | 'all'
+  /** Custom filter for decisions (return true to include). */
+  decisionFilter?: (decision: any) => boolean
+}
+
+export function generateKnowledgeTransfer(
+  graph: KnowledgeGraph,
+  options?: KnowledgeTransferOptions,
+): KnowledgeTransferData {
+  const architectural_decisions: KnowledgeTransferData['architectural_decisions'] = []
+  const key_patterns: string[] = []
+  const common_issues: string[] = []
+  const critical_files: string[] = []
+  const maxItems = options?.maxItems ?? Infinity
+  const focusAreas = options?.focusAreas ?? 'all'
+
+  if (focusAreas === 'all' || focusAreas === 'decisions') {
+    let decisions = graph.nodes.filter(n => n.type === 'decision')
+    if (options?.focusDecisions?.length) {
+      decisions = decisions.filter(d => options.focusDecisions!.includes(d.id))
+    }
+    if (options?.decisionFilter) {
+      decisions = decisions.filter(options.decisionFilter)
+    }
+    for (const decision of decisions.slice(0, maxItems)) {
+      const meta = decision.metadata as any
+      architectural_decisions.push({
+        title: meta.title,
+        decision: meta.decision,
+        context: meta.context,
+      })
+    }
+  }
+
+  if (focusAreas === 'all' || focusAreas === 'patterns') {
+    const constraints = graph.nodes.filter(n => n.type === 'constraint')
+    for (const constraint of constraints.slice(0, maxItems)) {
+      const meta = constraint.metadata as any
+      key_patterns.push(`${meta.constraint_type}: ${meta.rule_text}`)
+    }
+  }
+
+  if (focusAreas === 'all' || focusAreas === 'issues') {
+    const antiPatterns = graph.nodes.filter(n => n.type === 'assumption')
+    for (const assumption of antiPatterns.slice(0, maxItems)) {
+      const meta = assumption.metadata as any
+      if (meta.requires_confirmation) {
+        common_issues.push(`Assumpção não confirmada: ${meta.description}`)
+      }
+    }
+  }
+
+  if (focusAreas === 'all' || focusAreas === 'files') {
+    const files = graph.nodes.filter(n => n.type === 'file')
+    const criticalFiles = files.filter(f => {
+      const incoming = graph.relationships.filter(r => r.to === f.id)
+      return incoming.length > 3
+    })
+    
+    for (const file of criticalFiles.slice(0, Math.min(maxItems, 5))) {
+      const meta = file.metadata as any
+      critical_files.push(meta.path)
+    }
+  }
+
+  return {
+    architectural_decisions,
+    key_patterns,
+    common_issues,
+    critical_files,
+  }
+}
+
+export function formatKnowledgeTransfer(data: KnowledgeTransferData): string {
+  const lines = [
+    '## Transferência de Conhecimento',
+    '',
+  ]
+
+  if (data.architectural_decisions.length > 0) {
+    lines.push('### Decisões Arquiteturais')
+    for (const decision of data.architectural_decisions) {
+      lines.push(`#### ${decision.title}`)
+      lines.push(`- **Decisão:** ${decision.decision}`)
+      lines.push(`- **Contexto:** ${decision.context}`)
+      lines.push('')
+    }
+  }
+
+  if (data.key_patterns.length > 0) {
+    lines.push('### Padrões Principais')
+    for (const pattern of data.key_patterns) {
+      lines.push(`- ${pattern}`)
+    }
+  }
+
+  if (data.common_issues.length > 0) {
+    lines.push('', '### Problemas Comuns')
+    for (const issue of data.common_issues) {
+      lines.push(`- ${issue}`)
+    }
+  }
+
+  if (data.critical_files.length > 0) {
+    lines.push('', '### Arquivos Críticos')
+    for (const file of data.critical_files) {
+      lines.push(`- ${file}`)
+    }
+  }
+
+  lines.push(
+    '',
+    '### Próximos Passos',
+    '1. Leia as decisões arquiteturais',
+    '2. Entenda os padrões principais',
+    '3. Verifique os problemas comuns',
+    '4. Explore os arquivos críticos',
+  )
+
+  return lines.join('\n')
+}

package/src/sdd/migrations/fixes.ts

@@ -0,0 +1,154 @@
+import { registerMigration } from "./migration-runner.js"
+import { existsSync, readFileSync, writeFileSync } from "fs"
+import { join } from "path"
+
+// ── Migration 1: Sync graph.db from graph.yaml ──
+registerMigration({
+  id: "20260825_sync_graph_db_from_yaml",
+  description: "Rebuild graph.db from graph.yaml to ensure fresh data",
+  version: "1.0.0",
+  up: (projectDir: string) => {
+    const yamlPath = join(projectDir, ".sdd", "graph.yaml")
+    const dbPath = join(projectDir, ".sdd", "graph.db")
+    
+    if (!existsSync(yamlPath)) {
+      return { success: true, message: "No graph.yaml found, skipping" }
+    }
+    
+    if (existsSync(dbPath)) {
+      const yamlStat = require("fs").statSync(yamlPath)
+      const dbStat = require("fs").statSync(dbPath)
+      if (dbStat.mtimeMs >= yamlStat.mtimeMs) {
+        return { success: true, message: "graph.db is already up to date" }
+      }
+    }
+    
+    try {
+      const { createRepository } = require("../../sdd/persistence/repository.js")
+      const { SqliteGraphRepository } = require("../../sdd/persistence/sqlite.js")
+      
+      const yamlRepo = createRepository(projectDir)
+      if (!yamlRepo.isInitialized()) return { success: false, message: "SDD not initialized" }
+      const graph = yamlRepo.loadGraph()
+      
+      const sqliteRepo = new SqliteGraphRepository(projectDir)
+      sqliteRepo.saveGraph(graph)
+      
+      return {
+        success: true,
+        message: `Synced graph.db from graph.yaml (${graph.nodes.length} nodes)`,
+        files_modified: [dbPath],
+      }
+    } catch (err) {
+      return { success: false, message: `Failed to sync: ${err instanceof Error ? err.message : String(err)}` }
+    }
+  },
+})
+
+// ── Migration 2: Add missing priority fields ──
+registerMigration({
+  id: "20260825_add_missing_priority",
+  description: "Add default priority to nodes missing it",
+  version: "1.0.0",
+  up: (projectDir: string) => {
+    const yamlPath = join(projectDir, ".sdd", "graph.yaml")
+    if (!existsSync(yamlPath)) return { success: true, message: "No graph.yaml" }
+    
+    try {
+      const { createRepository } = require("../../sdd/persistence/repository.js")
+      const repo = createRepository(projectDir)
+      if (!repo.isInitialized()) return { success: false, message: "SDD not initialized" }
+      const graph = repo.loadGraph()
+      
+      let modified = false
+      for (const node of graph.nodes) {
+        if (node.type === "test" || node.type === "requirement") {
+          const meta = node.metadata as Record<string, unknown>
+          if (!meta.priority) {
+            meta.priority = "normal"
+            modified = true
+          }
+        }
+      }
+      
+      if (!modified) return { success: true, message: "All nodes already have priority" }
+      repo.saveGraph(graph)
+      return { success: true, message: "Added default priority", files_modified: [yamlPath] }
+    } catch (err) {
+      return { success: false, message: `Failed: ${err instanceof Error ? err.message : String(err)}` }
+    }
+  },
+})
+
+// ── Migration 3: Validate drift whitelist ──
+registerMigration({
+  id: "20260825_validate_drift_whitelist",
+  description: "Validate and normalize drift whitelist",
+  version: "1.0.0",
+  up: (projectDir: string) => {
+    const whitelistPath = join(projectDir, ".sdd", "drift-whitelist.json")
+    if (!existsSync(whitelistPath)) return { success: true, message: "No whitelist found" }
+    
+    try {
+      const whitelist = JSON.parse(readFileSync(whitelistPath, "utf-8"))
+      
+      if (!whitelist.entries || !Array.isArray(whitelist.entries)) {
+        writeFileSync(whitelistPath, JSON.stringify({ version: 1, entries: [] }, null, 2))
+        return { success: true, message: "Rebuilt corrupted whitelist" }
+      }
+      
+      let modified = false
+      for (const entry of whitelist.entries) {
+        const normalized = entry.file_path.replace(/^\.\//, "")
+        if (normalized !== entry.file_path) {
+          entry.file_path = normalized
+          modified = true
+        }
+      }
+      
+      if (modified) {
+        writeFileSync(whitelistPath, JSON.stringify(whitelist, null, 2))
+        return { success: true, message: "Normalized paths" }
+      }
+      return { success: true, message: "Whitelist is valid" }
+    } catch {
+      writeFileSync(whitelistPath, JSON.stringify({ version: 1, entries: [] }, null, 2))
+      return { success: true, message: "Rebuilt corrupted whitelist" }
+    }
+  },
+})
+
+// ── Migration 4: Validate graph structure ──
+registerMigration({
+  id: "20260825_validate_graph_structure",
+  description: "Validate and fix graph structure",
+  version: "1.0.0",
+  up: (projectDir: string) => {
+    const yamlPath = join(projectDir, ".sdd", "graph.yaml")
+    if (!existsSync(yamlPath)) return { success: true, message: "No graph.yaml" }
+    
+    try {
+      const { createRepository } = require("../../sdd/persistence/repository.js")
+      const repo = createRepository(projectDir)
+      if (!repo.isInitialized()) return { success: false, message: "SDD not initialized" }
+      const graph = repo.loadGraph()
+      
+      let fixed = 0
+      for (const node of graph.nodes) {
+        if (!node.id) continue
+        if (!node.type) { node.type = "unknown"; fixed++ }
+        if (!node.name) { node.name = node.id; fixed++ }
+        if (!node.status) { node.status = "DRAFT"; fixed++ }
+        if (!node.metadata) { node.metadata = {}; fixed++ }
+      }
+      
+      if (fixed === 0) return { success: true, message: "Graph structure is valid" }
+      repo.saveGraph(graph)
+      return { success: true, message: `Fixed ${fixed} issues`, files_modified: [yamlPath] }
+    } catch (err) {
+      return { success: false, message: `Failed: ${err instanceof Error ? err.message : String(err)}` }
+    }
+  },
+})
+
+export function getFixes(): void {}

package/src/sdd/migrations/index.ts

@@ -0,0 +1,14 @@
+export { 
+  runMigrations, 
+  hasPendingMigrations, 
+  loadMigrationHistory, 
+  saveMigrationHistory,
+  getMigrations,
+  registerMigration,
+  type Migration,
+  type MigrationResult 
+} from "./migration-runner.js"
+
+// Import fixes to register migrations
+import { getFixes } from "./fixes.js"
+getFixes()

package/src/sdd/migrations/migration-runner.ts

@@ -0,0 +1,118 @@
+import { existsSync, readFileSync, writeFileSync, readdirSync } from "fs"
+import { join, dirname } from "path"
+
+/**
+ * Migration definition for opencode-telos plugin updates.
+ * Each migration has a unique ID, description, and a function that applies the fix.
+ */
+export interface Migration {
+  id: string
+  description: string
+  version: string
+  up: (projectDir: string) => MigrationResult
+}
+
+export interface MigrationResult {
+  success: boolean
+  message: string
+  files_modified?: string[]
+}
+
+/**
+ * Migration registry - all migrations are registered here.
+ * ID format: YYYYMMDD_descriptive_name
+ */
+const MIGRATIONS: Migration[] = []
+
+/**
+ * Register a migration.
+ */
+export function registerMigration(migration: Migration): void {
+  MIGRATIONS.push(migration)
+}
+
+/**
+ * Get all registered migrations.
+ */
+export function getMigrations(): Migration[] {
+  return [...MIGRATIONS].sort((a, b) => a.id.localeCompare(b.id))
+}
+
+/**
+ * Migration history file path.
+ */
+function getMigrationHistoryPath(projectDir: string): string {
+  return join(projectDir, ".sdd", "migration-history.json")
+}
+
+/**
+ * Load migration history.
+ */
+export function loadMigrationHistory(projectDir: string): string[] {
+  const path = getMigrationHistoryPath(projectDir)
+  if (!existsSync(path)) return []
+  try {
+    const data = JSON.parse(readFileSync(path, "utf-8"))
+    return data.completed || []
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Save migration history.
+ */
+export function saveMigrationHistory(projectDir: string, completed: string[]): void {
+  const path = getMigrationHistoryPath(projectDir)
+  const dir = dirname(path)
+  if (!existsSync(dir)) {
+    const { mkdirSync } = require("fs")
+    mkdirSync(dir, { recursive: true })
+  }
+  writeFileSync(path, JSON.stringify({ completed, last_run: new Date().toISOString() }, null, 2), "utf-8")
+}
+
+/**
+ * Run all pending migrations.
+ * Returns the results of each migration run.
+ */
+export function runMigrations(projectDir: string): MigrationResult[] {
+  const completed = loadMigrationHistory(projectDir)
+  const pending = MIGRATIONS.filter((m) => !completed.includes(m.id))
+  
+  if (pending.length === 0) {
+    return [{ success: true, message: "No pending migrations" }]
+  }
+  
+  const results: MigrationResult[] = []
+  const newCompleted = [...completed]
+  
+  for (const migration of pending) {
+    try {
+      const result = migration.up(projectDir)
+      results.push(result)
+      
+      if (result.success) {
+        newCompleted.push(migration.id)
+      }
+    } catch (error) {
+      results.push({
+        success: false,
+        message: `Migration ${migration.id} failed: ${error instanceof Error ? error.message : String(error)}`,
+      })
+    }
+  }
+  
+  // Save history even if some migrations failed
+  saveMigrationHistory(projectDir, newCompleted)
+  
+  return results
+}
+
+/**
+ * Check if there are pending migrations.
+ */
+export function hasPendingMigrations(projectDir: string): boolean {
+  const completed = loadMigrationHistory(projectDir)
+  return MIGRATIONS.some((m) => !completed.includes(m.id))
+}

package/src/sdd/monitoring/setup.ts

@@ -0,0 +1,237 @@
+import type { KnowledgeGraph } from '../domain/types.js'
+
+export interface MonitoringSetup {
+  metrics: Array<{
+    name: string
+    type: 'counter' | 'gauge' | 'histogram' | 'summary'
+    description: string
+    labels?: string[]
+  }>
+  alerts: Array<{
+    name: string
+    condition: string
+    severity: 'critical' | 'warning' | 'info'
+    channels: string[]
+  }>
+  dashboards: Array<{
+    name: string
+    metrics: string[]
+  }>
+}
+
+export function setupMonitoring(graph: KnowledgeGraph): MonitoringSetup {
+  const metrics: MonitoringSetup['metrics'] = []
+  const alerts: MonitoringSetup['alerts'] = []
+  const dashboards: MonitoringSetup['dashboards'] = []
+
+  const endpoints = graph.nodes.filter(n => n.type === 'endpoint')
+  
+  for (const endpoint of endpoints) {
+    const meta = endpoint.metadata as any
+    const metricName = `http_requests_total{method="${meta.method}",path="${meta.path}"}`
+    
+    metrics.push({
+      name: metricName,
+      type: 'counter',
+      description: `Total de requisições para ${meta.method} ${meta.path}`,
+      labels: ['method', 'path', 'status'],
+    })
+  }
+
+  const entities = graph.nodes.filter(n => n.type === 'entity')
+  
+  if (entities.length > 0) {
+    metrics.push({
+      name: 'database_query_duration_seconds',
+      type: 'histogram',
+      description: 'Duração de consultas ao banco de dados',
+      labels: ['operation', 'table'],
+    })
+
+    metrics.push({
+      name: 'database_connections_active',
+      type: 'gauge',
+      description: 'Conexões ativas com o banco de dados',
+    })
+  }
+
+  alerts.push({
+    name: 'high_error_rate',
+    condition: 'rate(http_requests_total{status=~"5.."}[5m]) > 0.1',
+    severity: 'critical',
+    channels: ['email', 'slack'],
+  })
+
+  alerts.push({
+    name: 'high_latency',
+    condition: 'histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m])) > 1',
+    severity: 'warning',
+    channels: ['slack'],
+  })
+
+  dashboards.push({
+    name: 'API Overview',
+    metrics: ['http_requests_total', 'http_request_duration_seconds'],
+  })
+
+  dashboards.push({
+    name: 'Database',
+    metrics: ['database_query_duration_seconds', 'database_connections_active'],
+  })
+
+  return { metrics, alerts, dashboards }
+}
+
+export function formatMonitoringSetup(setup: MonitoringSetup): string {
+  const lines = [
+    '## Configuração de Monitoramento',
+    '',
+    `**Métricas:** ${setup.metrics.length}`,
+    `**Alertas:** ${setup.alerts.length}`,
+    `**Dashboards:** ${setup.dashboards.length}`,
+    '',
+    '### Métricas',
+  ]
+
+  for (const metric of setup.metrics) {
+    lines.push(`- **${metric.name}** (${metric.type}): ${metric.description}`)
+  }
+
+  lines.push('', '### Alertas')
+  for (const alert of setup.alerts) {
+    lines.push(`- **${alert.name}** (${alert.severity}): ${alert.condition}`)
+    lines.push(`  - Canais: ${alert.channels.join(', ')}`)
+  }
+
+  lines.push('', '### Dashboards')
+  for (const dashboard of setup.dashboards) {
+    lines.push(`- **${dashboard.name}**: ${dashboard.metrics.join(', ')}`)
+  }
+
+  return lines.join('\n')
+}
+
+export interface DashboardConfig {
+  title: string
+  panels: Array<{
+    title: string
+    type: 'graph' | 'stat' | 'table' | 'heatmap' | 'gauge'
+    query: string
+    position: { x: number; y: number; w: number; h: number }
+  }>
+  refresh_interval: string
+  time_range: string
+}
+
+export function generateDashboardConfig(
+  graph: KnowledgeGraph,
+  dashboardType: 'overview' | 'api' | 'database' | 'security'
+): DashboardConfig {
+  const panels: DashboardConfig['panels'] = []
+
+  if (dashboardType === 'overview') {
+    panels.push({
+      title: 'Requisições por Minuto',
+      type: 'graph',
+      query: 'rate(http_requests_total[1m])',
+      position: { x: 0, y: 0, w: 12, h: 6 },
+    })
+    panels.push({
+      title: 'Taxa de Erro',
+      type: 'stat',
+      query: 'rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m])',
+      position: { x: 12, y: 0, w: 6, h: 3 },
+    })
+    panels.push({
+      title: 'Latência P95',
+      type: 'stat',
+      query: 'histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))',
+      position: { x: 12, y: 3, w: 6, h: 3 },
+    })
+  } else if (dashboardType === 'api') {
+    const endpoints = graph.nodes.filter(n => n.type === 'endpoint').slice(0, 5)
+    for (let i = 0; i < endpoints.length; i++) {
+      const endpoint = endpoints[i]
+      const meta = endpoint.metadata as any
+      panels.push({
+        title: `${meta.method} ${meta.path}`,
+        type: 'graph',
+        query: `rate(http_requests_total{method="${meta.method}",path="${meta.path}"}[5m])`,
+        position: { x: (i % 3) * 8, y: Math.floor(i / 3) * 6, w: 8, h: 6 },
+      })
+    }
+  } else if (dashboardType === 'database') {
+    panels.push({
+      title: 'Conexões Ativas',
+      type: 'gauge',
+      query: 'database_connections_active',
+      position: { x: 0, y: 0, w: 6, h: 4 },
+    })
+    panels.push({
+      title: 'Duração de Consultas',
+      type: 'heatmap',
+      query: 'rate(database_query_duration_seconds_bucket[5m])',
+      position: { x: 6, y: 0, w: 6, h: 4 },
+    })
+    panels.push({
+      title: 'Consultas por Segundo',
+      type: 'graph',
+      query: 'rate(database_queries_total[5m])',
+      position: { x: 0, y: 4, w: 12, h: 4 },
+    })
+  } else if (dashboardType === 'security') {
+    panels.push({
+      title: 'Tentativas de Login',
+      type: 'graph',
+      query: 'rate(login_attempts_total[5m])',
+      position: { x: 0, y: 0, w: 6, h: 4 },
+    })
+    panels.push({
+      title: 'Falhas de Login',
+      type: 'stat',
+      query: 'rate(login_attempts_total{status="failed"}[5m])',
+      position: { x: 6, y: 0, w: 6, h: 4 },
+    })
+    panels.push({
+      title: 'Acessos Não Autorizados',
+      type: 'graph',
+      query: 'rate(unauthorized_access_attempts_total[5m])',
+      position: { x: 0, y: 4, w: 12, h: 4 },
+    })
+  }
+
+  return {
+    title: `Dashboard - ${dashboardType.charAt(0).toUpperCase() + dashboardType.slice(1)}`,
+    panels,
+    refresh_interval: '10s',
+    time_range: '1h',
+  }
+}
+
+export function formatDashboardConfig(config: DashboardConfig): string {
+  const lines = [
+    `## ${config.title}`,
+    '',
+    `**Intervalo de Atualização:** ${config.refresh_interval}`,
+    `**Período:** ${config.time_range}`,
+    `**Painéis:** ${config.panels.length}`,
+    '',
+    '### Painéis',
+  ]
+
+  for (const panel of config.panels) {
+    lines.push(`#### ${panel.title} (${panel.type})`)
+    lines.push(`- **Query:** \`${panel.query}\``)
+    lines.push(`- **Posição:** x=${panel.position.x}, y=${panel.position.y}, w=${panel.position.w}, h=${panel.position.h}`)
+    lines.push('')
+  }
+
+  lines.push(
+    '### Configuração Grafana',
+    '1. Importe este dashboard no Grafana',
+    '2. Configure a fonte de dados (Prometheus)',
+    '3. Ajuste os intervalos conforme necessário',
+  )
+
+  return lines.join('\n')
+}