opencode-telos 1.0.0

package/src/sdd/constitution/validator.ts

@@ -0,0 +1,253 @@
+import type { KnowledgeGraph, ConstitutionNode, AnyNode } from "../domain/types.js"
+import { getNodesByType } from "../graph/engine.js"
+import { GraphIndices } from "../graph/index.js"
+
+export interface ConstitutionViolation {
+  principle_id: string
+  node_id: string
+  description: string
+  severity: "must" | "should" | "may"
+}
+
+export interface ConstitutionResult {
+  violations: ConstitutionViolation[]
+  score: number
+  total_principles: number
+  checked_nodes: number
+}
+
+/**
+ * Options for controlling constitution validation scope.
+ */
+export interface ConstitutionValidationOptions {
+  /** Only validate these node types (e.g., ["entity", "endpoint"]). */
+  focusNodeTypes?: string[]
+  /** Only validate against these principle IDs. */
+  focusPrincipleIds?: string[]
+  /** Skip these principle IDs. */
+  excludePrincipleIds?: string[]
+  /** Skip these specific node IDs. */
+  excludeNodeIds?: string[]
+  /** Only validate nodes whose name/description contains these keywords. */
+  focusKeywords?: string[]
+  /** Skip scope regex pre-filtering (check all nodes against all principles). */
+  skipScopeFilter?: boolean
+  /** Maximum violations to report. */
+  maxResults?: number
+  /** Cache for previous check results (node_id+principle_id → violation or null). */
+  cache?: Map<string, ConstitutionViolation | null>
+}
+
+export function validateAgainstConstitution(
+  graph: KnowledgeGraph,
+  options?: ConstitutionValidationOptions,
+): ConstitutionResult {
+  const constitutions = getNodesByType<ConstitutionNode>(graph, "constitution")
+  const violations: ConstitutionViolation[] = []
+  const indices = GraphIndices.from(graph)
+
+  if (constitutions.length === 0) {
+    return { violations: [], score: 1, total_principles: 0, checked_nodes: 0 }
+  }
+
+  // Filter principles by options
+  let allPrinciples = constitutions.flatMap((c) =>
+    (c.metadata.principles || []).map((p) => ({
+      ...p,
+      constitution_id: c.id,
+    })),
+  )
+
+  if (options?.focusPrincipleIds?.length) {
+    allPrinciples = allPrinciples.filter(p => options.focusPrincipleIds!.includes(p.id))
+  }
+  if (options?.excludePrincipleIds?.length) {
+    const excludeSet = new Set(options.excludePrincipleIds)
+    allPrinciples = allPrinciples.filter(p => !excludeSet.has(p.id))
+  }
+
+  // Filter nodes by options
+  const excludeNodeSet = new Set(options?.excludeNodeIds || [])
+  let nodesToCheck = graph.nodes.filter(n =>
+    n.type !== "constitution" && n.type !== "project" && !excludeNodeSet.has(n.id)
+  )
+
+  if (options?.focusNodeTypes?.length) {
+    const typeSet = new Set(options.focusNodeTypes)
+    nodesToCheck = nodesToCheck.filter(n => typeSet.has(n.type))
+  }
+
+  if (options?.focusKeywords?.length) {
+    nodesToCheck = nodesToCheck.filter(n => {
+      const text = `${n.name} ${n.description || ''}`.toLowerCase()
+      return options.focusKeywords!.some(kw => text.includes(kw.toLowerCase()))
+    })
+  }
+
+  let checkedNodes = 0
+
+  // Build principle scope index for O(1) scope matching
+  const principleScopeIndex = options?.skipScopeFilter ? null : buildPrincipleScopeIndex(allPrinciples)
+
+  for (const node of nodesToCheck) {
+    checkedNodes++
+    const nodeStr = JSON.stringify(node).toLowerCase()
+
+    for (const principle of allPrinciples) {
+      // Smart scope filtering: skip principles that don't apply to this node type
+      if (principleScopeIndex) {
+        const applicableTypes = principleScopeIndex.get(principle.id)
+        if (applicableTypes && !applicableTypes.has(node.type)) continue
+      }
+
+      const scopeRegex = principle.scope ? new RegExp(principle.scope, "i") : null
+      if (scopeRegex && !scopeRegex.test(nodeStr)) continue
+
+      const cacheKey = `${node.id}||${principle.id}`
+      let violation: ConstitutionViolation | null = null
+      if (options?.cache?.has(cacheKey)) {
+        violation = options.cache.get(cacheKey) || null
+      } else {
+        violation = checkPrinciple(principle, node)
+        if (options?.cache) {
+          options.cache.set(cacheKey, violation)
+        }
+      }
+      if (violation) {
+        violations.push(violation)
+      }
+    }
+  }
+
+  // Apply max results limit
+  if (options?.maxResults && violations.length > options.maxResults) {
+    violations.splice(options.maxResults)
+  }
+
+  const mustViolations = violations.filter((v) => v.severity === "must").length
+  const shouldViolations = violations.filter((v) => v.severity === "should").length
+  const penalty = (mustViolations * 0.1 + shouldViolations * 0.03)
+  const score = Math.max(0, 1 - penalty)
+
+  return {
+    violations,
+    score,
+    total_principles: allPrinciples.length,
+    checked_nodes: checkedNodes,
+  }
+}
+
+/**
+ * Build an index mapping principle IDs to the node types they apply to.
+ * Extracted from scope regex patterns to avoid regex testing on every node.
+ */
+function buildPrincipleScopeIndex(
+  principles: Array<{ id: string; scope?: string }>,
+): Map<string, Set<string>> {
+  const index = new Map<string, Set<string>>()
+  for (const p of principles) {
+    if (!p.scope) continue
+    const types = new Set<string>()
+    // Extract node types from common scope patterns
+    if (/entity|entidade/i.test(p.scope)) types.add("entity")
+    if (/endpoint|rota|api/i.test(p.scope)) types.add("endpoint")
+    if (/feature|funcionalidade/i.test(p.scope)) types.add("feature")
+    if (/requirement|requisito/i.test(p.scope)) types.add("requirement")
+    if (/file|arquivo/i.test(p.scope)) types.add("file")
+    if (/architecture|arquitetura/i.test(p.scope)) types.add("architecture_component")
+    if (/rule|regra/i.test(p.scope)) types.add("business_rule")
+    if (/task|tarefa/i.test(p.scope)) types.add("task")
+    if (/test|teste/i.test(p.scope)) types.add("test")
+    if (types.size > 0) index.set(p.id, types)
+  }
+  return index
+}
+
+function checkPrinciple(
+  principle: { id: string; rule: string; severity: "must" | "should" | "may"; scope?: string },
+  node: AnyNode,
+): ConstitutionViolation | null {
+  const rule = principle.rule.toLowerCase()
+  const nodeJson = JSON.stringify(node).toLowerCase()
+  if (rule.includes("never") || rule.includes("nunca")) {
+    const forbidden = extractForbiddenPattern(rule)
+    if (forbidden && nodeJson.includes(forbidden)) {
+      return {
+        principle_id: principle.id,
+        node_id: node.id,
+        description: `Node "${node.name}" violates principle: ${principle.rule}`,
+        severity: principle.severity,
+      }
+    }
+  }
+
+  if (rule.includes("always") || rule.includes("sempre")) {
+    const required = extractRequiredPattern(rule)
+    if (required && !nodeJson.includes(required)) {
+      return {
+        principle_id: principle.id,
+        node_id: node.id,
+        description: `Node "${node.name}" missing required element per principle: ${principle.rule}`,
+        severity: principle.severity,
+      }
+    }
+  }
+
+  if (rule.includes("must not") || rule.includes("deve") && rule.includes("não")) {
+    const forbidden = extractForbiddenPattern(rule)
+    if (forbidden && nodeJson.includes(forbidden)) {
+      return {
+        principle_id: principle.id,
+        node_id: node.id,
+        description: `Node "${node.name}" violates constraint: ${principle.rule}`,
+        severity: principle.severity,
+      }
+    }
+  }
+
+  return null
+}
+
+function extractForbiddenPattern(rule: string): string | null {
+  const neverMatch = rule.match(/never\s+(?:use|include|contain|allow)\s+(\S+)/i)
+  if (neverMatch) return neverMatch[1].toLowerCase()
+
+  const nuncaMatch = rule.match(/nunca\s+(?:usar|incluir|conter|permitir)\s+(\S+)/i)
+  if (nuncaMatch) return nuncaMatch[1].toLowerCase()
+
+  return null
+}
+
+function extractRequiredPattern(rule: string): string | null {
+  const alwaysMatch = rule.match(/always\s+(?:use|include|contain)\s+(\S+)/i)
+  if (alwaysMatch) return alwaysMatch[1].toLowerCase()
+
+  const sempreMatch = rule.match(/sempre\s+(?:usar|incluir|conter)\s+(\S+)/i)
+  if (sempreMatch) return sempreMatch[1].toLowerCase()
+
+  return null
+}
+
+export function formatConstitutionResult(result: ConstitutionResult): string {
+  if (result.total_principles === 0) {
+    return "No constitution defined. Use sdd.constitution to define project principles."
+  }
+
+  const lines = [
+    `## Constitution Compliance`,
+    `**Principles:** ${result.total_principles}`,
+    `**Nodes checked:** ${result.checked_nodes}`,
+    `**Score:** ${(result.score * 100).toFixed(1)}%`,
+    `**Violations:** ${result.violations.length}`,
+  ]
+
+  if (result.violations.length > 0) {
+    lines.push("")
+    lines.push("### Violations")
+    for (const v of result.violations) {
+      lines.push(`- [${v.severity}] **${v.principle_id}** on ${v.node_id}: ${v.description}`)
+    }
+  }
+
+  return lines.join("\n")
+}

package/src/sdd/cost/estimator.ts

@@ -0,0 +1,147 @@
+import type { KnowledgeGraph } from '../domain/types.js'
+
+export interface CostEstimate {
+  infrastructure: Array<{
+    service: string
+    cost: number
+    unit: string
+  }>
+  development: Array<{
+    task: string
+    hours: number
+    rate: number
+  }>
+  total_infrastructure: number
+  total_development: number
+  total_monthly: number
+}
+
+export interface CostEstimationOptions {
+  /** Custom hourly rate (default: 50). */
+  customRate?: number
+  /** Custom rates per task type. Overrides customRate for matching tasks. */
+  customRates?: Record<string, number>
+  /** Only estimate costs for these areas: 'infrastructure' | 'development' | 'all'. */
+  focusAreas?: 'infrastructure' | 'development' | 'all'
+  /** Currency symbol (default: '$'). */
+  currency?: string
+  /** Custom infrastructure costs. Key: service name. */
+  customInfraCosts?: Record<string, number>
+}
+
+export function estimateCost(
+  graph: KnowledgeGraph,
+  options?: CostEstimationOptions,
+): CostEstimate {
+  const infrastructure: CostEstimate['infrastructure'] = []
+  const development: CostEstimate['development'] = []
+  const rate = options?.customRate ?? 50
+  const focusAreas = options?.focusAreas ?? 'all'
+  const customRates = options?.customRates ?? {}
+  const customInfra = options?.customInfraCosts ?? {}
+
+  const endpoints = graph.nodes.filter(n => n.type === 'endpoint')
+  const entities = graph.nodes.filter(n => n.type === 'entity')
+  const databases = graph.nodes.filter(n => n.type === 'database')
+
+  if (focusAreas === 'all' || focusAreas === 'infrastructure') {
+    infrastructure.push({
+      service: 'Servidor Web',
+      cost: customInfra['Servidor Web'] ?? 20,
+      unit: 'mês',
+    })
+
+    if (databases.length > 0) {
+      infrastructure.push({
+        service: 'Banco de Dados',
+        cost: customInfra['Banco de Dados'] ?? 25,
+        unit: 'mês',
+      })
+    }
+
+    if (endpoints.length > 10) {
+      infrastructure.push({
+        service: 'Load Balancer',
+        cost: customInfra['Load Balancer'] ?? 15,
+        unit: 'mês',
+      })
+    }
+
+    infrastructure.push({
+      service: 'Armazenamento',
+      cost: customInfra['Armazenamento'] ?? 5,
+      unit: 'mês',
+    })
+  }
+
+  if (focusAreas === 'all' || focusAreas === 'development') {
+    const setupRate = customRates['Setup inicial'] ?? rate
+    development.push({
+      task: 'Setup inicial',
+      hours: 8,
+      rate: setupRate,
+    })
+
+    const entityRate = customRates['Entidades e models'] ?? rate
+    development.push({
+      task: 'Entidades e models',
+      hours: entities.length * 4,
+      rate: entityRate,
+    })
+
+    const endpointRate = customRates['Endpoints da API'] ?? rate
+    development.push({
+      task: 'Endpoints da API',
+      hours: endpoints.length * 2,
+      rate: endpointRate,
+    })
+
+    const testRate = customRates['Testes'] ?? rate
+    development.push({
+      task: 'Testes',
+      hours: (entities.length + endpoints.length) * 1,
+      rate: testRate,
+    })
+  }
+
+  const total_infrastructure = infrastructure.reduce((sum, item) => sum + item.cost, 0)
+  const total_development = development.reduce((sum, item) => sum + (item.hours * item.rate), 0)
+  const total_monthly = total_infrastructure
+
+  return {
+    infrastructure,
+    development,
+    total_infrastructure,
+    total_development,
+    total_monthly,
+  }
+}
+
+export function formatCostEstimate(estimate: CostEstimate): string {
+  const lines = [
+    '## Estimativa de Custos',
+    '',
+    '### Infraestrutura (Mensal)',
+  ]
+
+  for (const item of estimate.infrastructure) {
+    lines.push(`- **${item.service}:** $${item.cost}/${item.unit}`)
+  }
+  lines.push(`- **Total Infraestrutura:** $${estimate.total_infrastructure}/mês`)
+
+  lines.push('', '### Desenvolvimento (Único)')
+  for (const item of estimate.development) {
+    lines.push(`- **${item.task}:** ${item.hours}h × $${item.rate}/h = $${item.hours * item.rate}`)
+  }
+  lines.push(`- **Total Desenvolvimento:** $${estimate.total_development}`)
+
+  lines.push(
+    '',
+    '### Resumo',
+    `- **Custo Mensal:** $${estimate.total_monthly}`,
+    `- **Custo Único:** $${estimate.total_development}`,
+    `- **Custo Total Primeiro Ano:** $${estimate.total_development + estimate.total_monthly * 12}`,
+  )
+
+  return lines.join('\n')
+}