opencode-telos 1.0.0

package/src/sdd/persistence/yaml.ts

@@ -0,0 +1,409 @@
+import * as yaml from "js-yaml"
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs"
+import { join, dirname } from "path"
+import type { KnowledgeGraph, AnyNode, NodeType, NodeStatus, Relationship } from "../domain/types.js"
+import { GraphIndices } from "../graph/index.js"
+import type { GraphRepository } from "./repository.js"
+import { getCacheManager } from "../cache/manager.js"
+import { recordLegitimateSave, validateGraphIntegrity, isGraphTampered } from "../graph/integrity-guard.js"
+
+export function readYaml<T>(filePath: string): T {
+  const content = readFileSync(filePath, "utf-8")
+  return yaml.load(content) as T
+}
+
+export function writeYaml(filePath: string, data: unknown): void {
+  const dir = dirname(filePath)
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  const content = yaml.dump(data, {
+    noRefs: true,
+    lineWidth: 120,
+    quotingType: '"',
+    forceQuotes: false,
+  })
+  writeFileSync(filePath, content, "utf-8")
+}
+
+export function readJson<T>(filePath: string): T {
+  const content = readFileSync(filePath, "utf-8")
+  return JSON.parse(content) as T
+}
+
+export function writeJson(filePath: string, data: unknown): void {
+  const dir = dirname(filePath)
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8")
+}
+
+export function ensureDir(dirPath: string): void {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true })
+  }
+}
+
+export function fileExists(filePath: string): boolean {
+  return existsSync(filePath)
+}
+
+export function listFiles(dirPath: string, extension?: string): string[] {
+  if (!existsSync(dirPath)) return []
+  const entries = readdirSync(dirPath, { withFileTypes: true })
+  const files: string[] = []
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      if (!extension || entry.name.endsWith(extension)) {
+        files.push(join(dirPath, entry.name))
+      }
+    }
+  }
+  return files
+}
+
+export function listDirs(dirPath: string): string[] {
+  if (!existsSync(dirPath)) return []
+  const entries = readdirSync(dirPath, { withFileTypes: true })
+  return entries
+    .filter((e) => e.isDirectory())
+    .map((e) => join(dirPath, e.name))
+}
+
+// ── Cache types ──────────────────────────────────────────────────────
+
+interface GraphCache {
+  graph: KnowledgeGraph
+  indices: GraphIndices
+  lastModified: number
+}
+
+// ── Repository ───────────────────────────────────────────────────────
+
+/**
+ * YAML-backed graph repository.
+ * Suitable for small to medium projects (<1000 nodes).
+ * Uses in-memory cache and pre-computed indices for fast queries.
+ */
+export class YamlGraphRepository implements GraphRepository {
+  private baseDir: string
+  private graphPath: string
+  private static cache: Map<string, GraphCache> = new Map()
+
+  constructor(projectDir: string) {
+    this.baseDir = join(projectDir, ".sdd")
+    this.graphPath = join(this.baseDir, "graph.yaml")
+  }
+
+  ensureSddDir(): void {
+    ensureDir(this.baseDir)
+    ensureDir(join(this.baseDir, "nodes"))
+    ensureDir(join(this.baseDir, "relationships"))
+    ensureDir(join(this.baseDir, "changes"))
+    ensureDir(join(this.baseDir, "snapshots"))
+    ensureDir(join(this.baseDir, "transactions"))
+  }
+
+  isInitialized(): boolean {
+    return fileExists(this.graphPath)
+  }
+
+  loadGraph(): KnowledgeGraph {
+    if (!this.isInitialized()) {
+      throw new Error("SDD not initialized. Run sdd.initialize first.")
+    }
+
+    // Check cache with revalidation
+    const cached = YamlGraphRepository.cache.get(this.graphPath)
+    if (cached) {
+      // Revalidation: check if file was modified externally
+      const currentMtime = (() => { try { return require("fs").statSync(this.graphPath).mtimeMs } catch { return 0 } })()
+      if (currentMtime <= cached.lastModified) {
+        // Cache is valid — also check incremental hash
+        const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
+        if (cacheMgr.isGraphHashValid(cached.indices.totalNodes + ":" + cached.indices.totalRelationships)) {
+          // Never expose the cached snapshot itself: callers intentionally
+          // mutate the graph before saveGraph(), and leaking this reference
+          // makes old/new comparisons impossible.
+          return structuredClone(cached.graph)
+        }
+      }
+      // File was modified externally or hash mismatch, invalidate cache
+      YamlGraphRepository.cache.delete(this.graphPath)
+    }
+
+    // Cross-process check
+    const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
+    if (cacheMgr.checkCrossProcessInvalidation(this.graphPath)) {
+      YamlGraphRepository.cache.delete(this.graphPath)
+    }
+
+    const graph = readYaml<KnowledgeGraph>(this.graphPath)
+    const indices = GraphIndices.from(graph)
+    const stat = (() => { try { return require("fs").statSync(this.graphPath).mtimeMs } catch { return 0 } })()
+
+    YamlGraphRepository.cache.set(this.graphPath, {
+      graph,
+      indices,
+      lastModified: stat,
+    })
+
+    // Initialize incremental hash
+    cacheMgr.initGraphHash(graph.nodes.length, graph.relationships.length)
+
+    // Anti-bypass: check for out-of-band modifications
+    const projectDir = require("path").dirname(this.baseDir)
+    try {
+      const tamperResult = validateGraphIntegrity(projectDir, graph)
+      if (tamperResult.tampered) {
+        // Graph was modified outside SDD workflow — attach warning to graph metadata
+        ;(graph.metadata as any).__tamper_warning = tamperResult.reason
+      }
+    } catch {}
+
+    return structuredClone(graph)
+  }
+
+  getIndices(): GraphIndices {
+    const cached = YamlGraphRepository.cache.get(this.graphPath)
+    if (cached) return cached.indices
+
+    const graph = this.loadGraph()
+    return GraphIndices.from(graph)
+  }
+
+  saveGraph(graph: KnowledgeGraph): void {
+    this.ensureSddDir()
+
+    // Acquire cross-process lock
+    const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
+    cacheMgr.acquireWriteLock()
+
+    try {
+      writeYaml(this.graphPath, graph)
+    } finally {
+      cacheMgr.releaseWriteLock()
+    }
+
+    // Record legitimate save for anti-bypass integrity tracking
+    const projectDir = require("path").dirname(this.baseDir)
+    try {
+      recordLegitimateSave(projectDir, graph)
+    } catch {}
+
+    // Keep an immutable cache snapshot.  Compute the dirty state before
+    // replacing it; doing this afterwards compares the new graph to itself.
+    const cached = YamlGraphRepository.cache.get(this.graphPath)
+    const { computeDirtyState } = require("../graph/index.js")
+    const snapshot = structuredClone(graph) as KnowledgeGraph
+    const dirty = computeDirtyState(cached?.graph || null, snapshot)
+
+    // Rebuilding the in-memory index is deterministic and avoids stale
+    // readonly totals/search entries after additions and removals. YAML is
+    // limited to small graphs; large graphs migrate to SQLite.
+    const indices = GraphIndices.from(snapshot)
+    YamlGraphRepository.cache.set(this.graphPath, {
+      graph: snapshot,
+      indices,
+      lastModified: Date.now(),
+    })
+    /*
+    if (cached) {
+      // Compute dirty nodes incrementally
+      const oldGraph = cached.graph
+      const { computeDirtyState } = require("../graph/index.js")
+      const dirty = computeDirtyState(oldGraph, graph)
+
+      if (!dirty.allChanged && dirty.dirtyNodeIds.size <= 50) {
+        // Incremental update: modify only affected entries
+        for (const nodeId of dirty.dirtyNodeIds) {
+          const oldNode = oldGraph.nodes.find(n => n.id === nodeId)
+          const newNode = graph.nodes.find(n => n.id === nodeId)
+          if (oldNode && newNode) {
+            cached.indices.updateNode(oldNode, newNode)
+          } else if (newNode) {
+            cached.indices.addNode(newNode)
+          } else if (oldNode) {
+            cached.indices.removeNode(nodeId)
+          }
+        }
+        // Update relationship indices incrementally
+        const oldRelKeys = new Set(oldGraph.relationships.map(r => `${r.from}||${r.to}||${r.type}`))
+        const newRelKeys = new Set(graph.relationships.map(r => `${r.from}||${r.to}||${r.type}`))
+        for (const rel of graph.relationships) {
+          const key = `${rel.from}||${rel.to}||${rel.type}`
+          if (!oldRelKeys.has(key)) {
+            cached.indices.addRelationship(rel)
+          }
+        }
+        for (const rel of oldGraph.relationships) {
+          const key = `${rel.from}||${rel.to}||${rel.type}`
+          if (!newRelKeys.has(key)) {
+            cached.indices.removeRelationship(rel)
+          }
+        }
+      } else {
+        // Full rebuild needed
+        YamlGraphRepository.cache.delete(this.graphPath)
+        const indices = GraphIndices.from(graph)
+        YamlGraphRepository.cache.set(this.graphPath, {
+          graph,
+          indices,
+          lastModified: Date.now(),
+        })
+      }
+    } else {
+      // No previous cache, full build
+      const indices = GraphIndices.from(graph)
+      YamlGraphRepository.cache.set(this.graphPath, {
+        graph,
+        indices,
+        lastModified: Date.now(),
+      })
+    }
+    */
+
+    // Update incremental hash
+    cacheMgr.initGraphHash(graph.nodes.length, graph.relationships.length)
+
+    // A: Granular invalidation — only invalidate caches for changed types
+    if (dirty.allChanged || dirty.dirtyTypes.size > 10) {
+      // Too many types changed — full invalidation is faster
+      cacheMgr.invalidateAll()
+    } else if (dirty.dirtyTypes.size > 0) {
+      // A: Partial invalidation — only affected types
+      cacheMgr.invalidatePartial([...dirty.dirtyTypes])
+    }
+
+    // G: Save graph snapshot to disk for cross-session restore
+    cacheMgr.saveGraphSnapshot(graph)
+  }
+
+  getStorageType(): "yaml" {
+    return "yaml"
+  }
+
+  isCacheValid(): boolean {
+    const cached = YamlGraphRepository.cache.get(this.graphPath)
+    if (!cached) return false
+    try {
+      const stat = require("fs").statSync(this.graphPath)
+      return stat.mtimeMs <= cached.lastModified
+    } catch {
+      return false
+    }
+  }
+
+  invalidateCache(): void {
+    YamlGraphRepository.cache.delete(this.graphPath)
+  }
+
+  createProject(projectId: string, name: string, description?: string): KnowledgeGraph {
+    this.ensureSddDir()
+    const now = new Date().toISOString()
+    const graph: KnowledgeGraph = {
+      version: "1.0.0",
+      project_id: projectId,
+      nodes: [
+        {
+          id: projectId,
+          type: "project",
+          name,
+          description,
+          status: "DRAFT",
+          version: 1,
+          metadata: { name, description },
+          created_at: now,
+          updated_at: now,
+        },
+      ],
+      relationships: [],
+      metadata: {
+        created_at: now,
+        updated_at: now,
+        sdd_version: "1.0.0",
+      },
+    }
+    this.saveGraph(graph)
+    return graph
+  }
+
+  createSnapshot(description: string): string {
+    const graph = this.loadGraph()
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+    const snapshotId = `snapshot-${timestamp}`
+    const snapshotPath = join(this.baseDir, "snapshots", `${snapshotId}.yaml`)
+    writeYaml(snapshotPath, { id: snapshotId, timestamp: new Date().toISOString(), description, graph_state: graph })
+    return snapshotId
+  }
+
+  listSnapshots(): string[] {
+    const snapDir = join(this.baseDir, "snapshots")
+    // Get both YAML files and directories (for snapshot folders)
+    const yamlFiles = listFiles(snapDir, ".yaml")
+    const dirs = listDirs(snapDir)
+    return [...yamlFiles, ...dirs]
+  }
+
+  migrateTo(target: "yaml" | "sqlite", projectDir: string): GraphRepository {
+    const graph = this.loadGraph()
+
+    if (target === "sqlite") {
+      const { SqliteGraphRepository } = require("./sqlite.js")
+      const repo = new SqliteGraphRepository(projectDir)
+      repo.saveGraph(graph)
+      return repo
+    }
+
+    // Already YAML
+    return this
+  }
+
+  // ── Optimized queries (use indices) ─────────────────────────────
+
+  getNodeCount(): number {
+    const cached = YamlGraphRepository.cache.get(this.graphPath)
+    if (cached) return cached.indices.totalNodes
+    // Quick count without full parse
+    try {
+      const content = readFileSync(this.graphPath, "utf-8")
+      const matches = content.match(/^  - id:/gm)
+      return matches ? matches.length : 0
+    } catch {
+      return 0
+    }
+  }
+
+  getRelationshipCount(): number {
+    const cached = YamlGraphRepository.cache.get(this.graphPath)
+    if (cached) return cached.indices.totalRelationships
+    return 0
+  }
+
+  getNodesByType(type: NodeType): AnyNode[] {
+    // Check per-type cache first
+    const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
+    const graphVersion = (() => { try { return this.loadGraph().metadata.updated_at } catch { return "" } })()
+    const versionNum = graphVersion ? new Date(graphVersion).getTime() : 0
+    const cached = cacheMgr.getCachedNodesByType(type, versionNum)
+    if (cached) return cached
+
+    const indices = this.getIndices()
+    const nodes = indices.getNodesByType(type)
+    cacheMgr.setCachedNodesByType(type, nodes, versionNum)
+    return nodes
+  }
+
+  getNodesByStatus(status: NodeStatus): AnyNode[] {
+    const indices = this.getIndices()
+    return indices.getNodesByStatus(status)
+  }
+
+  getNodeById(id: string): AnyNode | undefined {
+    // Check byId map directly (O(1))
+    const indices = this.getIndices()
+    return indices.byId.get(id)
+  }
+
+  getRelationshipsForNode(nodeId: string): Relationship[] {
+    const indices = this.getIndices()
+    return indices.getRelationships(nodeId)
+  }
+}

package/src/sdd/promises/classifier.ts

@@ -0,0 +1,253 @@
+import type { KnowledgeGraph } from "../domain/types.js"
+import { getNodesByType, getNodesByTypeIndexed } from "../graph/engine.js"
+import { GraphIndices } from "../graph/index.js"
+
+/**
+ * A dependency rule maps a keyword pattern to the graph infrastructure
+ * required to verify a promise. If the infrastructure doesn't exist
+ * in the graph, the promise is marked as "unverifiable".
+ *
+ * The AI can configure these rules to adapt to different project types.
+ */
+export interface DependencyRule {
+  /** Keywords that trigger this rule (any match activates it) */
+  keywords: string[]
+  /** Description of what this rule checks */
+  description: string
+  /**
+   * Function that checks if the required infrastructure exists in the graph.
+   * Returns true if the promise CAN be verified (infrastructure exists).
+   */
+  checkExists: (graph: KnowledgeGraph, indices: GraphIndices) => boolean
+}
+
+/**
+ * Default dependency rules for infrastructure detection.
+ * The AI can extend or override these per-project.
+ */
+export const DEFAULT_DEPENDENCY_RULES: DependencyRule[] = [
+  {
+    keywords: ["docker", "container", "dockerfile", "docker-compose", "image"],
+    description: "Docker infrastructure required",
+    checkExists: (graph) => {
+      // Check for Docker-related architecture components
+      const archNodes = getNodesByType(graph, "architecture_component")
+      const hasDockerArch = archNodes.some(n => {
+        const tech = (n.metadata as any).technology?.toLowerCase() || ""
+        return tech.includes("docker")
+      })
+      // Check for Docker files
+      const files = getNodesByType(graph, "file")
+      const hasDockerFiles = files.some(f => {
+        const path = (f.metadata as any).path?.toLowerCase() || ""
+        return path.includes("dockerfile") || path.includes("docker-compose") || path.includes(".dockerignore")
+      })
+      return hasDockerArch || hasDockerFiles
+    },
+  },
+  {
+    keywords: ["health check", "healthcheck", "liveness", "readiness", "probes"],
+    description: "Health check infrastructure required",
+    checkExists: (graph) => {
+      const archNodes = getNodesByType(graph, "architecture_component")
+      return archNodes.some(n => {
+        const name = n.name.toLowerCase()
+        const tech = (n.metadata as any).technology?.toLowerCase() || ""
+        return name.includes("health") || name.includes("monitoring") || tech.includes("health")
+      })
+    },
+  },
+  {
+    keywords: ["rollback", "roll-back", "auto-rollback", "automático"],
+    description: "Rollback infrastructure required",
+    checkExists: (graph) => {
+      // Check for migration nodes with rollback scripts
+      const migrations = getNodesByType(graph, "migration")
+      if (migrations.length > 0) return true
+      // Check for architecture components related to deployment
+      const archNodes = getNodesByType(graph, "architecture_component")
+      return archNodes.some(n => {
+        const name = n.name.toLowerCase()
+        return name.includes("deploy") || name.includes("ci") || name.includes("cd")
+      })
+    },
+  },
+  {
+    keywords: ["dlq", "dead letter", "dead-letter", "idempotency", "idempotent"],
+    description: "Message queue infrastructure required",
+    checkExists: (graph) => {
+      const archNodes = getNodesByType(graph, "architecture_component")
+      return archNodes.some(n => {
+        const tech = (n.metadata as any).technology?.toLowerCase() || ""
+        const name = n.name.toLowerCase()
+        return tech.includes("queue") || tech.includes("rabbitmq") || tech.includes("kafka") ||
+               tech.includes("bull") || tech.includes("redis") ||
+               name.includes("queue") || name.includes("worker") || name.includes("event")
+      })
+    },
+  },
+  {
+    keywords: ["observability", "observabilidade", "logging", "tracing", "metrics", "prometheus", "grafana", "datadog"],
+    description: "Observability stack required",
+    checkExists: (graph) => {
+      const archNodes = getNodesByType(graph, "architecture_component")
+      const hasObs = archNodes.some(n => {
+        const tech = (n.metadata as any).technology?.toLowerCase() || ""
+        const name = n.name.toLowerCase()
+        return tech.includes("prometheus") || tech.includes("grafana") || tech.includes("datadog") ||
+               tech.includes("opentelemetry") || tech.includes("otel") ||
+               name.includes("observ") || name.includes("monitor") || name.includes("log")
+      })
+      // Also check for metric/alert nodes
+      const metrics = getNodesByType(graph, "metric")
+      const alerts = getNodesByType(graph, "alert")
+      return hasObs || metrics.length > 0 || alerts.length > 0
+    },
+  },
+  {
+    keywords: ["semver", "semantic version", "versioning"],
+    description: "Versioning infrastructure required",
+    checkExists: (graph) => {
+      // Check for manifest/config files with versioning
+      const files = getNodesByType(graph, "file")
+      return files.some(f => {
+        const path = (f.metadata as any).path?.toLowerCase() || ""
+        return path.includes("package.json") || path.includes("manifest") || path.includes("version")
+      })
+    },
+  },
+  {
+    keywords: ["performance", "perf", "latência", "response time", "tempo de resposta"],
+    description: "Performance measurement infrastructure required",
+    checkExists: (graph) => {
+      // Check for SLA nodes or metric nodes related to performance
+      const slas = getNodesByType(graph, "sla")
+      const metrics = getNodesByType(graph, "metric")
+      const hasPerfSla = slas.some(s => {
+        const metric = (s.metadata as any).metric?.toLowerCase() || ""
+        return metric.includes("response") || metric.includes("latency") || metric.includes("performance")
+      })
+      const hasPerfMetric = metrics.some(m => {
+        const name = (m.metadata as any).metric_name?.toLowerCase() || ""
+        return name.includes("response") || name.includes("latency") || name.includes("p99")
+      })
+      return hasPerfSla || hasPerfMetric
+    },
+  },
+  {
+    keywords: ["cpt", "dynamic registration", "registro dinâmico"],
+    description: "Dynamic registration infrastructure required",
+    checkExists: (graph) => {
+      // Check for plugin system or module system architecture
+      const archNodes = getNodesByType(graph, "architecture_component")
+      return archNodes.some(n => {
+        const name = n.name.toLowerCase()
+        return name.includes("plugin") || name.includes("module") || name.includes("registry")
+      })
+    },
+  },
+  {
+    keywords: ["cli search", "busca cli", "search cli"],
+    description: "CLI search infrastructure required",
+    checkExists: (graph) => {
+      // Check for CLI-related architecture or files
+      const archNodes = getNodesByType(graph, "architecture_component")
+      const hasCliArch = archNodes.some(n => {
+        const name = n.name.toLowerCase()
+        return name.includes("cli") || name.includes("command")
+      })
+      const files = getNodesByType(graph, "file")
+      const hasCliFiles = files.some(f => {
+        const path = (f.metadata as any).path?.toLowerCase() || ""
+        return path.includes("cli") || path.includes("command")
+      })
+      return hasCliArch || hasCliFiles
+    },
+  },
+  {
+    keywords: ["layer ordering", "layer order", "ordering", "ordenação"],
+    description: "Layer ordering infrastructure required",
+    checkExists: (graph) => {
+      // Check for multiple architecture components with defined layers
+      const archNodes = getNodesByType(graph, "architecture_component")
+      const layers = new Set(archNodes.map(n => (n.metadata as any).layer).filter(Boolean))
+      return layers.size >= 2
+    },
+  },
+  {
+    keywords: ["checksum", "hash", "integridade"],
+    description: "Checksum infrastructure required",
+    checkExists: (graph) => {
+      // Check for build/deploy pipeline architecture
+      const archNodes = getNodesByType(graph, "architecture_component")
+      return archNodes.some(n => {
+        const name = n.name.toLowerCase()
+        return name.includes("build") || name.includes("pipeline") || name.includes("ci")
+      })
+    },
+  },
+]
+
+/**
+ * Classify whether a promise is verifiable based on its description
+ * and the current graph state.
+ *
+ * The AI can pass custom rules to override or extend the defaults.
+ */
+export function classifyPromiseVerifiability(
+  description: string,
+  graph: KnowledgeGraph,
+  customRules?: DependencyRule[],
+): { verifiable: boolean; reason?: string } {
+  const rules = customRules || DEFAULT_DEPENDENCY_RULES
+  const indices = GraphIndices.from(graph)
+  const descLower = description.toLowerCase()
+
+  for (const rule of rules) {
+    // Check if any keyword matches the promise description
+    const matchesKeyword = rule.keywords.some(kw => descLower.includes(kw.toLowerCase()))
+    if (!matchesKeyword) continue
+
+    // Keyword matched — now check if the required infrastructure exists
+    const infrastructureExists = rule.checkExists(graph, indices)
+    if (!infrastructureExists) {
+      return {
+        verifiable: false,
+        reason: `Requires ${rule.description} (no matching infrastructure in graph)`,
+      }
+    }
+  }
+
+  return { verifiable: true }
+}
+
+/**
+ * Batch classify a list of promises, returning those that are unverifiable.
+ */
+export function findUnverifiablePromises(
+  promises: Array<{ id: string; description: string; status: string }>,
+  graph: KnowledgeGraph,
+  customRules?: DependencyRule[],
+): Array<{ id: string; description: string; reason: string }> {
+  const results: Array<{ id: string; description: string; reason: string }> = []
+
+  for (const promise of promises) {
+    if (promise.status !== "pending") continue
+
+    const classification = classifyPromiseVerifiability(
+      promise.description,
+      graph,
+      customRules,
+    )
+
+    if (!classification.verifiable && classification.reason) {
+      results.push({
+        id: promise.id,
+        description: promise.description,
+        reason: classification.reason,
+      })
+    }
+  }
+
+  return results
+}