opencode-telos 1.0.0

package/src/sdd/graph/pruner.ts

@@ -0,0 +1,221 @@
+import type { KnowledgeGraph, FileNode, SymbolNode, TestNode, ChangeNode } from "../domain/types.js"
+import { getNodesByType, removeNode } from "./engine.js"
+import { existsSync, readFileSync } from "fs"
+import { join } from "path"
+
+export interface PruneReport {
+  removed_nodes: Array<{ id: string; type: string; name: string; reason: string }>
+  deprecated_changes: string[]
+  total_removed: number
+  total_deprecated: number
+  space_freed_estimate: string
+}
+
+/**
+ * Prune obsolete nodes from the graph:
+ * - FileNodes pointing to deleted files
+ * - SymbolNodes pointing to non-existent symbols
+ * - TestNodes for deleted test files
+ * - Old completed ChangeNodes (>30 days)
+ * - Duplicate relationships
+ */
+export function pruneGraph(graph: KnowledgeGraph, projectDir: string): PruneReport {
+  const report: PruneReport = {
+    removed_nodes: [],
+    deprecated_changes: [],
+    total_removed: 0,
+    total_deprecated: 0,
+    space_freed_estimate: "0 nodes",
+  }
+
+  // 1. Remove FileNodes for deleted files
+  pruneDeadFileNodes(graph, projectDir, report)
+
+  // 2. Remove SymbolNodes for deleted symbols
+  pruneDeadSymbolNodes(graph, projectDir, report)
+
+  // 3. Remove TestNodes for deleted test files
+  pruneDeadTestNodes(graph, projectDir, report)
+
+  // 4. Archive old completed ChangeNodes
+  archiveOldChanges(graph, report)
+
+  // 5. Remove duplicate relationships
+  pruneDuplicateRelationships(graph, report)
+
+  report.space_freed_estimate = `${report.total_removed} node(s) removed, ${report.total_deprecated} change(s) archived`
+  return report
+}
+
+function pruneDeadFileNodes(graph: KnowledgeGraph, projectDir: string, report: PruneReport): void {
+  const fileNodes = getNodesByType<FileNode>(graph, "file")
+  for (const fileNode of fileNodes) {
+    const path = fileNode.metadata.path
+    if (!path) continue
+    const fullPath = join(projectDir, path)
+    if (!existsSync(fullPath)) {
+      report.removed_nodes.push({
+        id: fileNode.id,
+        type: "file",
+        name: fileNode.name,
+        reason: `File no longer exists: ${path}`,
+      })
+      try {
+        removeNode(graph, fileNode.id)
+        report.total_removed++
+      } catch {}
+    }
+  }
+}
+
+function pruneDeadSymbolNodes(graph: KnowledgeGraph, projectDir: string, report: PruneReport): void {
+  const symbolNodes = getNodesByType<SymbolNode>(graph, "symbol")
+  for (const symNode of symbolNodes) {
+    const filePath = symNode.metadata.file_path
+    if (!filePath) continue
+    const fullPath = join(projectDir, filePath)
+    if (!existsSync(fullPath)) {
+      report.removed_nodes.push({
+        id: symNode.id,
+        type: "symbol",
+        name: symNode.name,
+        reason: `Source file no longer exists: ${filePath}`,
+      })
+      try {
+        removeNode(graph, symNode.id)
+        report.total_removed++
+      } catch {}
+      continue
+    }
+
+    // Check if the symbol still exists in the file
+    try {
+      const content = readFileSync(fullPath, "utf-8")
+      const name = symNode.name.split(".").pop() || symNode.name // Handle Class.method
+      if (!content.includes(name)) {
+        report.removed_nodes.push({
+          id: symNode.id,
+          type: "symbol",
+          name: symNode.name,
+          reason: `Symbol "${name}" no longer found in ${filePath}`,
+        })
+        try {
+          removeNode(graph, symNode.id)
+          report.total_removed++
+        } catch {}
+      }
+    } catch {}
+  }
+}
+
+function pruneDeadTestNodes(graph: KnowledgeGraph, projectDir: string, report: PruneReport): void {
+  const testNodes = getNodesByType<TestNode>(graph, "test")
+  for (const testNode of testNodes) {
+    const target = (testNode.metadata as any).target
+    if (!target) continue
+    const fullPath = join(projectDir, target)
+    if (!existsSync(fullPath)) {
+      report.removed_nodes.push({
+        id: testNode.id,
+        type: "test",
+        name: testNode.name,
+        reason: `Test file no longer exists: ${target}`,
+      })
+      try {
+        removeNode(graph, testNode.id)
+        report.total_removed++
+      } catch {}
+    }
+  }
+}
+
+function archiveOldChanges(graph: KnowledgeGraph, report: PruneReport): void {
+  const now = Date.now()
+  const ARCHIVE_DAYS = 30
+
+  const changeNodes = getNodesByType<ChangeNode>(graph, "change")
+  for (const change of changeNodes) {
+    if (change.status !== "COMPLETED") continue
+    const age = now - new Date(change.updated_at).getTime()
+    if (age > ARCHIVE_DAYS * 24 * 60 * 60 * 1000) {
+      change.status = "DEPRECATED"
+      change.updated_at = new Date().toISOString()
+      change.metadata = {
+        ...change.metadata,
+        auto_archived: true,
+        archived_reason: `Auto-archived: completed ${Math.floor(age / (24 * 60 * 60 * 1000))} days ago`,
+      }
+      report.deprecated_changes.push(change.id)
+      report.total_deprecated++
+    }
+  }
+}
+
+function pruneDuplicateRelationships(graph: KnowledgeGraph, report: PruneReport): void {
+  const seen = new Set<string>()
+  const toRemove: number[] = []
+
+  for (let i = 0; i < graph.relationships.length; i++) {
+    const rel = graph.relationships[i]
+    const key = `${rel.from}||${rel.to}||${rel.type}`
+    if (seen.has(key)) {
+      toRemove.push(i)
+      report.total_removed++
+    } else {
+      seen.add(key)
+    }
+  }
+
+  // Remove in reverse order to maintain indices
+  for (let i = toRemove.length - 1; i >= 0; i--) {
+    graph.relationships.splice(toRemove[i], 1)
+  }
+}
+
+/**
+ * Format prune report as readable markdown.
+ */
+export function formatPruneReport(report: PruneReport): string {
+  const lines = [
+    "## Graph Pruning Report",
+    "",
+  ]
+
+  if (report.total_removed === 0 && report.total_deprecated === 0) {
+    lines.push("✅ Graph is clean. No obsolete nodes found.")
+    return lines.join("\n")
+  }
+
+  if (report.removed_nodes.length > 0) {
+    lines.push(`### Removed Nodes (${report.removed_nodes.length})`)
+    const byType = new Map<string, typeof report.removed_nodes>()
+    for (const node of report.removed_nodes) {
+      const list = byType.get(node.type) || []
+      list.push(node)
+      byType.set(node.type, list)
+    }
+    for (const [type, nodes] of byType) {
+      lines.push(`\n**${type}** (${nodes.length}):`)
+      for (const node of nodes.slice(0, 10)) {
+        lines.push(`- ${node.name}: ${node.reason}`)
+      }
+      if (nodes.length > 10) lines.push(`- ... and ${nodes.length - 10} more`)
+    }
+    lines.push("")
+  }
+
+  if (report.deprecated_changes.length > 0) {
+    lines.push(`### Archived Changes (${report.deprecated_changes.length})`)
+    lines.push(`Changes older than 30 days marked as DEPRECATED:`)
+    for (const id of report.deprecated_changes.slice(0, 10)) {
+      lines.push(`- ${id}`)
+    }
+    if (report.deprecated_changes.length > 10) {
+      lines.push(`- ... and ${report.deprecated_changes.length - 10} more`)
+    }
+    lines.push("")
+  }
+
+  lines.push(`**Summary:** ${report.space_freed_estimate}`)
+  return lines.join("\n")
+}

package/src/sdd/graph/traverse.ts

@@ -0,0 +1,331 @@
+import type { KnowledgeGraph, AnyNode, Relationship } from "../domain/types.js"
+import { getNode, getOutgoing, getIncoming } from "./engine.js"
+
+export interface TraverseOptions {
+  max_depth?: number
+  edge_types?: string[]
+  include_start?: boolean
+}
+
+export function bfsOutgoing(
+  graph: KnowledgeGraph,
+  startId: string,
+  options: TraverseOptions = {},
+): { nodes: AnyNode[]; edges: Relationship[]; distances: Map<string, number> } {
+  const maxDepth = options.max_depth ?? 10
+  const edgeTypes = options.edge_types ? new Set(options.edge_types) : null
+
+  const visited = new Set<string>()
+  const distances = new Map<string, number>()
+  const resultNodes: AnyNode[] = []
+  const resultEdges: Relationship[] = []
+
+  const queue: Array<{ id: string; depth: number }> = [{ id: startId, depth: 0 }]
+  visited.add(startId)
+  distances.set(startId, 0)
+
+  if (options.include_start) {
+    const startNode = getNode(graph, startId)
+    if (startNode) resultNodes.push(startNode)
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift()!
+    if (current.depth >= maxDepth) continue
+
+    const outgoing = getOutgoing(graph, current.id)
+    for (const edge of outgoing) {
+      if (edgeTypes && !edgeTypes.has(edge.type)) continue
+      if (visited.has(edge.to)) continue
+
+      visited.add(edge.to)
+      distances.set(edge.to, current.depth + 1)
+      resultEdges.push(edge)
+
+      const targetNode = getNode(graph, edge.to)
+      if (targetNode) resultNodes.push(targetNode)
+
+      queue.push({ id: edge.to, depth: current.depth + 1 })
+    }
+  }
+
+  return { nodes: resultNodes, edges: resultEdges, distances }
+}
+
+export function bfsIncoming(
+  graph: KnowledgeGraph,
+  startId: string,
+  options: TraverseOptions = {},
+): { nodes: AnyNode[]; edges: Relationship[]; distances: Map<string, number> } {
+  const maxDepth = options.max_depth ?? 10
+  const edgeTypes = options.edge_types ? new Set(options.edge_types) : null
+
+  const visited = new Set<string>()
+  const distances = new Map<string, number>()
+  const resultNodes: AnyNode[] = []
+  const resultEdges: Relationship[] = []
+
+  const queue: Array<{ id: string; depth: number }> = [{ id: startId, depth: 0 }]
+  visited.add(startId)
+  distances.set(startId, 0)
+
+  if (options.include_start) {
+    const startNode = getNode(graph, startId)
+    if (startNode) resultNodes.push(startNode)
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift()!
+    if (current.depth >= maxDepth) continue
+
+    const incoming = getIncoming(graph, current.id)
+    for (const edge of incoming) {
+      if (edgeTypes && !edgeTypes.has(edge.type)) continue
+      if (visited.has(edge.from)) continue
+
+      visited.add(edge.from)
+      distances.set(edge.from, current.depth + 1)
+      resultEdges.push(edge)
+
+      const sourceNode = getNode(graph, edge.from)
+      if (sourceNode) resultNodes.push(sourceNode)
+
+      queue.push({ id: edge.from, depth: current.depth + 1 })
+    }
+  }
+
+  return { nodes: resultNodes, edges: resultEdges, distances }
+}
+
+export function bfsBoth(
+  graph: KnowledgeGraph,
+  startId: string,
+  options: TraverseOptions = {},
+): { nodes: AnyNode[]; edges: Relationship[]; distances: Map<string, number> } {
+  const maxDepth = options.max_depth ?? 10
+  const edgeTypes = options.edge_types ? new Set(options.edge_types) : null
+
+  const visited = new Set<string>()
+  const distances = new Map<string, number>()
+  const resultNodes: AnyNode[] = []
+  const resultEdges: Relationship[] = []
+
+  const queue: Array<{ id: string; depth: number }> = [{ id: startId, depth: 0 }]
+  visited.add(startId)
+  distances.set(startId, 0)
+
+  if (options.include_start) {
+    const startNode = getNode(graph, startId)
+    if (startNode) resultNodes.push(startNode)
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift()!
+    if (current.depth >= maxDepth) continue
+
+    const outgoing = getOutgoing(graph, current.id)
+    const incoming = getIncoming(graph, current.id)
+    const allEdges = [...outgoing, ...incoming]
+
+    for (const edge of allEdges) {
+      if (edgeTypes && !edgeTypes.has(edge.type)) continue
+      const neighborId = edge.from === current.id ? edge.to : edge.from
+      if (visited.has(neighborId)) continue
+
+      visited.add(neighborId)
+      distances.set(neighborId, current.depth + 1)
+      resultEdges.push(edge)
+
+      const neighborNode = getNode(graph, neighborId)
+      if (neighborNode) resultNodes.push(neighborNode)
+
+      queue.push({ id: neighborId, depth: current.depth + 1 })
+    }
+  }
+
+  return { nodes: resultNodes, edges: resultEdges, distances }
+}
+
+export function findPath(
+  graph: KnowledgeGraph,
+  fromId: string,
+  toId: string,
+  maxDepth: number = 10,
+): AnyNode[] | null {
+  const visited = new Set<string>()
+  const queue: Array<{ id: string; path: string[] }> = [{ id: fromId, path: [fromId] }]
+  visited.add(fromId)
+
+  while (queue.length > 0) {
+    const current = queue.shift()!
+    if (current.id === toId) {
+      return current.path
+        .map((id) => getNode(graph, id))
+        .filter(Boolean) as AnyNode[]
+    }
+    if (current.path.length > maxDepth) continue
+
+    const outgoing = getOutgoing(graph, current.id)
+    for (const edge of outgoing) {
+      if (!visited.has(edge.to)) {
+        visited.add(edge.to)
+        queue.push({ id: edge.to, path: [...current.path, edge.to] })
+      }
+    }
+  }
+
+  return null
+}
+
+export function computeImpact(
+  graph: KnowledgeGraph,
+  nodeId: string,
+  maxDepth: number = 5,
+): { direct: AnyNode[]; indirect: AnyNode[]; potential: AnyNode[] } {
+  const depth1 = bfsOutgoing(graph, nodeId, { max_depth: 1, include_start: false })
+  const depthN = bfsOutgoing(graph, nodeId, { max_depth: maxDepth, include_start: false })
+
+  const directIds = new Set(depth1.nodes.map((n) => n.id))
+  const indirectIds = new Set<string>()
+  const potentialIds = new Set<string>()
+
+  for (const node of depthN.nodes) {
+    if (directIds.has(node.id)) continue
+    const dist = depthN.distances.get(node.id) ?? 0
+    if (dist <= 2) indirectIds.add(node.id)
+    else potentialIds.add(node.id)
+  }
+
+  return {
+    direct: depth1.nodes,
+    indirect: [...indirectIds].map((id) => getNode(graph, id)).filter(Boolean) as AnyNode[],
+    potential: [...potentialIds].map((id) => getNode(graph, id)).filter(Boolean) as AnyNode[],
+  }
+}
+
+export interface ImpactAction {
+  node_id: string
+  node_type: string
+  node_name: string
+  action: "modify" | "create" | "update_relationship" | "add_test" | "update_spec"
+  description: string
+  target_files: string[]
+  priority: "high" | "medium" | "low"
+}
+
+/**
+ * Compute impact with concrete actions: what files to modify,
+ * what relationships to update, what tests to add.
+ */
+export function computeImpactActions(
+  graph: KnowledgeGraph,
+  nodeId: string,
+  maxDepth: number = 3,
+): ImpactAction[] {
+  const impact = computeImpact(graph, nodeId, maxDepth)
+  const actions: ImpactAction[] = []
+  const sourceNode = getNode(graph, nodeId)
+  if (!sourceNode) return actions
+
+  // Direct impact → modify actions
+  for (const node of impact.direct) {
+    const files = findNodeFiles(graph, node.id)
+    const actionType: ImpactAction["action"] = node.type === "file" ? "modify" :
+      node.type === "test" ? "add_test" : "update_spec"
+
+    actions.push({
+      node_id: node.id,
+      node_type: node.type,
+      node_name: node.name,
+      action: actionType,
+      description: generateActionDescription(sourceNode, node),
+      target_files: files,
+      priority: "high",
+    })
+  }
+
+  // Indirect impact → medium priority
+  for (const node of impact.indirect) {
+    const files = findNodeFiles(graph, node.id)
+    actions.push({
+      node_id: node.id,
+      node_type: node.type,
+      node_name: node.name,
+      action: "update_spec",
+      description: `Verify ${node.type} "${node.name}" still aligns after changes to "${sourceNode.name}"`,
+      target_files: files,
+      priority: "medium",
+    })
+  }
+
+  // Potential impact → low priority, verification needed
+  for (const node of impact.potential.slice(0, 10)) {
+    const files = findNodeFiles(graph, node.id)
+    actions.push({
+      node_id: node.id,
+      node_type: node.type,
+      node_name: node.name,
+      action: "update_spec",
+      description: `Check if ${node.type} "${node.name}" needs updates`,
+      target_files: files,
+      priority: "low",
+    })
+  }
+
+  return actions
+}
+
+function findNodeFiles(graph: KnowledgeGraph, nodeId: string): string[] {
+  const files: string[] = []
+  // Check if the node itself is a file
+  const node = getNode(graph, nodeId)
+  if (node?.type === "file") {
+    const path = (node.metadata as any).path
+    if (path) files.push(path)
+    return files
+  }
+
+  // Find file nodes connected to this node
+  for (const rel of graph.relationships) {
+    if (rel.from === nodeId || rel.to === nodeId) {
+      const otherId = rel.from === nodeId ? rel.to : rel.from
+      const other = getNode(graph, otherId)
+      if (other?.type === "file") {
+        const path = (other.metadata as any).path
+        if (path) files.push(path)
+      }
+      if (other?.type === "symbol") {
+        const path = (other.metadata as any).file_path
+        if (path) files.push(path)
+      }
+    }
+  }
+  return [...new Set(files)]
+}
+
+function generateActionDescription(source: AnyNode, target: AnyNode): string {
+  const relType = target.type
+  if (relType === "entity") return `Update entity "${target.name}" to reflect changes in "${source.name}"`
+  if (relType === "endpoint") return `Update endpoint "${target.name}" API contract`
+  if (relType === "requirement") return `Verify requirement "${target.name}" is still satisfied`
+  if (relType === "test") return `Update test "${target.name}" for new behavior`
+  if (relType === "business_rule") return `Check if business rule "${target.name}" still applies`
+  if (relType === "file") return `Modify file "${target.name}"`
+  return `Update ${relType} "${target.name}"`
+}
+
+export function getSubgraph(
+  graph: KnowledgeGraph,
+  nodeIds: string[],
+): KnowledgeGraph {
+  const idSet = new Set(nodeIds)
+  return {
+    version: graph.version,
+    project_id: graph.project_id,
+    nodes: graph.nodes.filter((n) => idSet.has(n.id)),
+    relationships: graph.relationships.filter(
+      (r) => idSet.has(r.from) && idSet.has(r.to),
+    ),
+    metadata: { ...graph.metadata },
+  }
+}

package/src/sdd/incidents/manager.ts

@@ -0,0 +1,87 @@
+import type { KnowledgeGraph, IncidentNode } from '../domain/types.js'
+
+export interface IncidentWorkflow {
+  id: string
+  title: string
+  severity: 'SEV1' | 'SEV2' | 'SEV3' | 'SEV4'
+  impact: string
+}
+
+export function createIncident(
+  _graph: KnowledgeGraph,
+  workflow: IncidentWorkflow
+): IncidentNode {
+  const incidentId = `incident-${Date.now()}`
+
+  const incident: IncidentNode = {
+    id: incidentId,
+    type: 'incident',
+    name: `Incidente: ${workflow.title}`,
+    description: workflow.impact,
+    status: 'PROPOSED',
+    version: 1,
+    metadata: {
+      incident_title: workflow.title,
+      severity: workflow.severity,
+      status: 'open',
+      impact: workflow.impact,
+      timeline: [
+        {
+          timestamp: new Date().toISOString(),
+          action: 'Incidente reportado',
+          author: 'system',
+        },
+      ],
+    },
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  }
+
+  return incident
+}
+
+export function getIncidentInstructions(incident: IncidentNode): string {
+  const lines = [
+    '## Gestão de Incidente',
+    '',
+    `**Título:** ${incident.metadata.incident_title}`,
+    `**Severidade:** ${incident.metadata.severity}`,
+    `**Status:** ${incident.metadata.status}`,
+    `**Impacto:** ${incident.metadata.impact}`,
+    '',
+    '### Procedimentos por Severidade',
+    '',
+    '**SEV1 (Crítico):**',
+    '- Notificar stakeholders imediatamente',
+    '- Ativar equipe de resposta a incidentes',
+    '- Comunicação a cada 15 minutos',
+    '',
+    '**SEV2 (Alto):**',
+    '- Notificar equipe responsável',
+    '- Atualização a cada 30 minutos',
+    '',
+    '**SEV3 (Médio):**',
+    '- Documentar e agendar correção',
+    '- Atualização quando houver progresso',
+    '',
+    '**SEV4 (Baixo):**',
+    '- Documentar para correção futura',
+    '',
+    '### Timeline',
+  ]
+
+  for (const entry of incident.metadata.timeline) {
+    lines.push(`- ${entry.timestamp}: ${entry.action} (${entry.author})`)
+  }
+
+  lines.push(
+    '',
+    '### Próximos Passos',
+    '1. Identificar causa raiz',
+    '2. Implementar correção',
+    '3. Verificar resolução',
+    '4. Documentar lições aprendidas',
+  )
+
+  return lines.join('\n')
+}