opencode-telos 1.0.0

package/src/code-intelligence/ast/fallback.ts

@@ -0,0 +1,44 @@
+import { extname } from "path"
+import { emptyParsedFile, rangeFromOffsets } from "./common.js"
+import type { LanguageParser, ParsedFile } from "./ir.js"
+
+const LANGUAGE_BY_EXTENSION: Record<string, string> = {
+  ".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript",
+  ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript",
+  ".py": "python", ".go": "go", ".rs": "rust", ".java": "java", ".rb": "ruby",
+  ".vue": "vue", ".svelte": "svelte",
+}
+
+export function languageForPath(filePath: string): string | undefined {
+  return LANGUAGE_BY_EXTENSION[extname(filePath).toLowerCase()]
+}
+
+export class FallbackParser implements LanguageParser {
+  readonly name = "regex-fallback"
+  readonly version = "1"
+
+  supports(): boolean { return true }
+
+  parse(filePath: string, content: string): ParsedFile {
+    const language = languageForPath(filePath) || "unknown"
+    const result = emptyParsedFile(filePath, language, this.name, this.version, content, "fallback", 0.25)
+    const addSymbol = (name: string, kind: "class" | "function", start: number, exported = false) => {
+      result.symbols.push({
+        name,
+        qualified_name: name,
+        kind,
+        range: rangeFromOffsets(content, start, start + name.length),
+        exported,
+      })
+    }
+    for (const match of content.matchAll(/\b(?:class|interface|struct|enum)\s+([A-Za-z_]\w*)/g)) {
+      addSymbol(match[1], "class", match.index || 0)
+    }
+    for (const match of content.matchAll(/\b(?:function|def|fn)\s+([A-Za-z_]\w*)/g)) {
+      addSymbol(match[1], "function", match.index || 0)
+    }
+    result.diagnostics.push({ message: "No structured parser is available for this file; fallback results are non-authoritative", severity: "warning" })
+    return result
+  }
+}
+

package/src/code-intelligence/ast/index.ts

@@ -0,0 +1,4 @@
+export * from "./ir.js"
+export * from "./registry.js"
+export * from "./cache.js"
+export * from "./metrics.js"

package/src/code-intelligence/ast/ir.ts

@@ -0,0 +1,91 @@
+export type AnalysisSource = "ast" | "fallback"
+export type ResolutionStatus = "resolved" | "ambiguous" | "unresolved"
+
+export interface SourcePosition {
+  line: number
+  column: number
+}
+
+export interface SourceRange {
+  start: SourcePosition
+  end: SourcePosition
+  start_index: number
+  end_index: number
+}
+
+export type SymbolKind =
+  | "class"
+  | "function"
+  | "method"
+  | "variable"
+  | "interface"
+  | "type"
+  | "enum"
+  | "field"
+  | "module"
+
+export interface ImportInfo {
+  source: string
+  names: string[]
+  kind: "import" | "require" | "use" | "include"
+  range: SourceRange
+  resolution_status: ResolutionStatus
+  resolved_path?: string
+}
+
+export interface ExportInfo {
+  name: string
+  source?: string
+  kind: "named" | "default" | "reexport" | "public"
+  range: SourceRange
+}
+
+export interface SymbolInfo {
+  name: string
+  qualified_name: string
+  kind: SymbolKind
+  visibility?: string
+  parent?: string
+  signature?: string
+  range: SourceRange
+  exported: boolean
+}
+
+export interface ParsedRelation {
+  type: "extends" | "implements" | "calls" | "contains" | "imports"
+  from: string
+  to: string
+  range: SourceRange
+  confidence: number
+}
+
+export interface ParseDiagnostic {
+  message: string
+  severity: "error" | "warning" | "info"
+  range?: SourceRange
+}
+
+export interface ParsedFile {
+  path: string
+  language: string
+  parser: string
+  parser_version: string
+  content_hash: string
+  analysis_source: AnalysisSource
+  confidence: number
+  package_name?: string
+  imports: ImportInfo[]
+  exports: ExportInfo[]
+  symbols: SymbolInfo[]
+  relations: ParsedRelation[]
+  test_names: string[]
+  diagnostics: ParseDiagnostic[]
+}
+
+export interface LanguageParser {
+  readonly name: string
+  readonly version: string
+  supports(language: string, extension: string): boolean
+  parse(filePath: string, content: string): ParsedFile
+}
+

package/src/code-intelligence/ast/metrics.ts

@@ -0,0 +1,65 @@
+import type { ParsedFile } from "./ir.js"
+
+export interface AstExpectation {
+  symbols?: string[]
+  imports?: string[]
+  exports?: string[]
+}
+
+export interface AstMetric {
+  precision: number
+  recall: number
+  true_positive: number
+  false_positive: number
+  false_negative: number
+}
+
+export interface AstQualityReport {
+  file: string
+  parser: string
+  source: "ast" | "fallback"
+  symbols: AstMetric
+  imports: AstMetric
+  exports: AstMetric
+  diagnostics: number
+}
+
+function metric(actualValues: string[], expectedValues: string[]): AstMetric {
+  const actual = new Set(actualValues)
+  const expected = new Set(expectedValues)
+  const truePositive = [...actual].filter((value) => expected.has(value)).length
+  const falsePositive = [...actual].filter((value) => !expected.has(value)).length
+  const falseNegative = [...expected].filter((value) => !actual.has(value)).length
+  return {
+    precision: actual.size === 0 ? expected.size === 0 ? 1 : 0 : truePositive / actual.size,
+    recall: expected.size === 0 ? actual.size === 0 ? 1 : 0 : truePositive / expected.size,
+    true_positive: truePositive,
+    false_positive: falsePositive,
+    false_negative: falseNegative,
+  }
+}
+
+export function evaluateParsedFile(parsed: ParsedFile, expected: AstExpectation): AstQualityReport {
+  return {
+    file: parsed.path,
+    parser: parsed.parser,
+    source: parsed.analysis_source,
+    symbols: metric(parsed.symbols.map((symbol) => symbol.qualified_name), expected.symbols || []),
+    imports: metric(parsed.imports.map((item) => item.source), expected.imports || []),
+    exports: metric(parsed.exports.map((item) => item.name), expected.exports || []),
+    diagnostics: parsed.diagnostics.length,
+  }
+}
+
+export function averageAstMetric(reports: AstQualityReport[], key: "symbols" | "imports" | "exports"): AstMetric {
+  if (reports.length === 0) return { precision: 0, recall: 0, true_positive: 0, false_positive: 0, false_negative: 0 }
+  const values = reports.map((report) => report[key])
+  return {
+    precision: values.reduce((sum, value) => sum + value.precision, 0) / values.length,
+    recall: values.reduce((sum, value) => sum + value.recall, 0) / values.length,
+    true_positive: values.reduce((sum, value) => sum + value.true_positive, 0),
+    false_positive: values.reduce((sum, value) => sum + value.false_positive, 0),
+    false_negative: values.reduce((sum, value) => sum + value.false_negative, 0),
+  }
+}
+

package/src/code-intelligence/ast/registry.ts

@@ -0,0 +1,28 @@
+import { extname } from "path"
+import { ComponentParser } from "./component.js"
+import { FallbackParser, languageForPath } from "./fallback.js"
+import { TreeSitterParser } from "./tree-sitter.js"
+import { TypeScriptParser } from "./typescript.js"
+import type { LanguageParser, ParsedFile } from "./ir.js"
+
+const typescriptParser = new TypeScriptParser()
+const treeSitterParser = new TreeSitterParser()
+const componentParser = new ComponentParser()
+const fallbackParser = new FallbackParser()
+
+const parsers: LanguageParser[] = [typescriptParser, treeSitterParser, componentParser]
+
+export function getLanguageParser(filePath: string): LanguageParser {
+  const extension = extname(filePath).toLowerCase()
+  const language = languageForPath(filePath) || "unknown"
+  return parsers.find((parser) => parser.supports(language, extension)) || fallbackParser
+}
+
+export function parseSourceFile(filePath: string, content: string): ParsedFile {
+  return getLanguageParser(filePath).parse(filePath, content)
+}
+
+export function listLanguageParsers(): string[] {
+  return parsers.map((parser) => parser.name)
+}
+

package/src/code-intelligence/ast/tree-sitter.ts

@@ -0,0 +1,226 @@
+import Parser from "tree-sitter"
+import Python from "tree-sitter-python"
+import Go from "tree-sitter-go"
+import Rust from "tree-sitter-rust"
+import Java from "tree-sitter-java"
+import Ruby from "tree-sitter-ruby"
+import { extname } from "path"
+import { emptyParsedFile, rangeFromOffsets } from "./common.js"
+import type { LanguageParser, ParsedFile, ParsedRelation, SourceRange, SymbolInfo } from "./ir.js"
+
+type SyntaxNode = Parser.SyntaxNode
+
+const GRAMMARS: Record<string, { language: unknown; version: string }> = {
+  python: { language: Python, version: "0.25.0" },
+  go: { language: Go, version: "0.25.0" },
+  rust: { language: Rust, version: "0.24.0" },
+  java: { language: Java, version: "0.23.5" },
+  ruby: { language: Ruby, version: "0.23.1" },
+}
+
+const EXTENSIONS: Record<string, string> = {
+  ".py": "python", ".go": "go", ".rs": "rust", ".java": "java", ".rb": "ruby",
+}
+
+function nodeName(node: SyntaxNode): string | undefined {
+  const name = node.childForFieldName("name")
+  return name?.text || node.namedChildren.find((child) => ["identifier", "type_identifier", "field_identifier", "constant"].includes(child.type))?.text
+}
+
+function fieldText(node: SyntaxNode, field: string): string | undefined {
+  return node.childForFieldName(field)?.text
+}
+
+function visibilityFor(language: string, text: string): string | undefined {
+  if (language === "rust") return text.trimStart().startsWith("pub") ? "public" : "private"
+  if (language === "java") {
+    if (/\bpublic\b/.test(text)) return "public"
+    if (/\bprotected\b/.test(text)) return "protected"
+    if (/\bprivate\b/.test(text)) return "private"
+    return "package"
+  }
+  if (language === "go") return /^[A-Z]/.test(text) ? "public" : "private"
+  if (language === "ruby" || language === "python") return text.trimStart().startsWith("_") ? "private" : "public"
+  return undefined
+}
+
+function isPublic(language: string, name: string, text: string): boolean {
+  if (language === "rust") return text.trimStart().startsWith("pub")
+  if (language === "java") return /\bpublic\b/.test(text)
+  if (language === "go") return /^[A-Z]/.test(name)
+  return !name.startsWith("_")
+}
+
+function isTypeNode(language: string, type: string): boolean {
+  if (language === "python") return type === "class_definition"
+  if (language === "go") return type === "type_spec"
+  if (language === "rust") return ["struct_item", "enum_item", "trait_item"].includes(type)
+  if (language === "java") return ["class_declaration", "interface_declaration", "enum_declaration", "record_declaration"].includes(type)
+  return ["class", "module"].includes(type)
+}
+
+function symbolKind(language: string, type: string): SymbolInfo["kind"] | undefined {
+  if (isTypeNode(language, type)) {
+    if (language === "ruby" && type === "module") return "module"
+    if (type.includes("interface") || type === "trait_item") return "interface"
+    if (type.includes("enum")) return "enum"
+    return "class"
+  }
+  if (["function_definition", "function_declaration", "function_item", "method", "method_declaration", "constructor_declaration", "singleton_method"].includes(type)) {
+    return ["method", "method_declaration", "constructor_declaration", "singleton_method"].includes(type) ? "method" : "function"
+  }
+  if (type === "function_signature_item" || type === "method_elem") return "method"
+  if (type === "field_declaration") return "field"
+  if (type === "type_alias_declaration") return "type"
+  return undefined
+}
+
+function importSource(node: SyntaxNode): string | undefined {
+  const path = node.childForFieldName("path") || node.childForFieldName("module_name") || node.childForFieldName("argument")
+  if (path) return path.text.replace(/^['\"]|['\"]$/g, "")
+  const named = node.namedChildren.find((child) => child.type.includes("string") || child.type.includes("identifier"))
+  return named?.text.replace(/^['\"]|['\"]$/g, "")
+}
+
+function isImportNode(language: string, type: string): boolean {
+  if (language === "python") return ["import_statement", "import_from_statement"].includes(type)
+  if (language === "go") return type === "import_spec"
+  if (language === "rust") return type === "use_declaration"
+  if (language === "java") return type === "import_declaration"
+  return false
+}
+
+function importKind(language: string): "import" | "require" | "use" | "include" {
+  if (language === "rust") return "use"
+  return "import"
+}
+
+function textRange(content: string, node: SyntaxNode): SourceRange {
+  return rangeFromOffsets(content, node.startIndex, node.endIndex)
+}
+
+export class TreeSitterParser implements LanguageParser {
+  readonly name = "tree-sitter"
+  readonly version = "0.25"
+
+  supports(language: string, extension: string): boolean {
+    return Boolean(GRAMMARS[language] && EXTENSIONS[extension.toLowerCase()] === language)
+  }
+
+  parse(filePath: string, content: string): ParsedFile {
+    const extension = extname(filePath).toLowerCase()
+    const language = EXTENSIONS[extension] || "unknown"
+    const grammar = GRAMMARS[language]
+    const result = emptyParsedFile(filePath, language, `${this.name}:${language}`, grammar?.version || this.version, content)
+    if (!grammar) {
+      result.analysis_source = "fallback"
+      result.confidence = 0
+      result.diagnostics.push({ message: `No Tree-sitter grammar registered for ${language}`, severity: "error" })
+      return result
+    }
+
+    const parser = new Parser()
+    parser.setLanguage(grammar.language as Parser.Language)
+    parser.setTimeoutMicros(750_000)
+    const tree = parser.parse(content)
+    const contexts: string[] = []
+
+    const addSymbol = (node: SyntaxNode, name: string, kind: SymbolInfo["kind"]): string => {
+      const parent = contexts.at(-1)
+      const qualified = parent ? `${parent}.${name}` : name
+      const symbol: SymbolInfo = {
+        name,
+        qualified_name: qualified,
+        kind,
+        parent,
+        visibility: visibilityFor(language, node.text),
+        signature: node.text.split("{")[0].split("\n")[0].trim(),
+        range: textRange(content, node),
+        exported: isPublic(language, name, node.text),
+      }
+      result.symbols.push(symbol)
+      if (symbol.exported) result.exports.push({ name, kind: "public", range: symbol.range })
+      return qualified
+    }
+
+    const addRelation = (relation: ParsedRelation["type"], from: string, to: string, node: SyntaxNode, confidence = 0.9) => {
+      if (from && to) result.relations.push({ type: relation, from, to, range: textRange(content, node), confidence })
+    }
+
+    const walk = (node: SyntaxNode): void => {
+      if (node.isMissing) result.diagnostics.push({ message: `Missing syntax node: ${node.type}`, severity: "warning", range: textRange(content, node) })
+      if (language === "go" && node.type === "package_clause") result.package_name = node.childForFieldName("name")?.text
+      if (language === "java" && node.type === "package_declaration") result.package_name = node.namedChildren.at(-1)?.text
+      if (language === "ruby" && node.type === "call") {
+        const method = node.childForFieldName("method")?.text
+        const stringNode = node.namedChildren.find((child) => child.type.includes("string"))
+        if ((method === "require" || method === "require_relative") && stringNode) {
+          result.imports.push({ source: stringNode.text.replace(/^['\"]|['\"]$/g, ""), names: [], kind: "require", range: textRange(content, node), resolution_status: "unresolved" })
+        }
+      }
+      if (isImportNode(language, node.type)) {
+        const source = importSource(node)
+        if (source) result.imports.push({ source, names: node.namedChildren.map((child) => child.text).slice(0, 8), kind: importKind(language), range: textRange(content, node), resolution_status: "unresolved" })
+      }
+
+      let pushed = false
+      let contextual = false
+      if (language === "go" && node.type === "method_declaration") {
+        const receiverType = node.childForFieldName("receiver")?.descendantsOfType(["type_identifier"])[0]?.text
+        if (receiverType) { contexts.push(receiverType.replace(/^\*/, "")); contextual = true }
+      }
+      if (language === "rust" && node.type === "impl_item") {
+        const target = fieldText(node, "type")
+        const trait = fieldText(node, "trait")
+        if (target) { contexts.push(target); contextual = true }
+        if (target && trait) addRelation("implements", target, trait, node)
+      }
+      const kind = symbolKind(language, node.type)
+      const name = nodeName(node)
+      if (kind && name) {
+        const qualified = addSymbol(node, name, kind)
+        contexts.push(qualified)
+        pushed = true
+        if (language === "python" && node.type === "class_definition") {
+          const supers = node.childForFieldName("superclasses")
+          for (const child of supers?.namedChildren || []) addRelation("extends", qualified, child.text, child)
+        }
+        if (language === "ruby" && node.type === "class") {
+          const superclass = node.childForFieldName("superclass")
+          if (superclass) addRelation("extends", qualified, superclass.text, superclass)
+        }
+        if (language === "java" && ["class_declaration", "interface_declaration"].includes(node.type)) {
+          const superclass = node.childForFieldName("superclass")
+          if (superclass) addRelation("extends", qualified, superclass.text, superclass)
+          const interfaces = node.childForFieldName("interfaces")
+          for (const item of interfaces?.namedChildren || []) addRelation("implements", qualified, item.text, item)
+        }
+      }
+
+      if (node.type.includes("call") || node.type === "call") {
+        const callee = node.childForFieldName("function") || node.childForFieldName("method") || node.namedChildren[0]
+        const current = contexts.at(-1)
+        if (callee && current) {
+          const target = callee.text.replace(/^self[.:#]/, "")
+          addRelation("calls", current, target, node, 0.6)
+          if (["describe", "test", "it", "specify"].includes(target)) {
+            const stringNode = node.namedChildren.find((child) => child.type.includes("string"))
+            if (stringNode) result.test_names.push(stringNode.text.replace(/^['\"]|['\"]$/g, ""))
+          }
+        }
+      }
+
+      for (const child of node.namedChildren) walk(child)
+      if (pushed) contexts.pop()
+      if (contextual) contexts.pop()
+    }
+
+    walk(tree.rootNode)
+    if (tree.rootNode.hasError) {
+      result.confidence = 0.85
+      result.diagnostics.push({ message: "Tree-sitter recovered one or more syntax errors", severity: "warning", range: textRange(content, tree.rootNode) })
+    }
+    result.package_name = result.symbols.find((symbol) => symbol.kind === "module")?.name
+    return result
+  }
+}

package/src/code-intelligence/ast/typescript.ts

@@ -0,0 +1,140 @@
+import ts from "typescript"
+import { basename, extname } from "path"
+import { contentHash, emptyParsedFile, rangeFromOffsets } from "./common.js"
+import type { ExportInfo, ImportInfo, LanguageParser, ParsedFile, SymbolInfo } from "./ir.js"
+
+function textOf(node: ts.Node, source: ts.SourceFile): string {
+  return node.getText(source)
+}
+
+function isExported(node: ts.Node): boolean {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined
+  return Boolean(modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword))
+}
+
+function symbolRange(node: ts.Node, source: ts.SourceFile) {
+  return rangeFromOffsets(source.text, node.getStart(source), node.getEnd())
+}
+
+export class TypeScriptParser implements LanguageParser {
+  readonly name = "typescript-compiler-api"
+  readonly version = ts.version
+
+  supports(language: string, extension: string): boolean {
+    return (language === "typescript" || language === "javascript") &&
+      [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"].includes(extension.toLowerCase())
+  }
+
+  parse(filePath: string, content: string): ParsedFile {
+    const extension = extname(filePath).toLowerCase()
+    const language = extension.includes("js") || extension === ".jsx" ? "javascript" : "typescript"
+    const scriptKind = extension === ".tsx" ? ts.ScriptKind.TSX
+      : extension === ".jsx" ? ts.ScriptKind.JSX
+        : language === "typescript" ? ts.ScriptKind.TS : ts.ScriptKind.JS
+    const source = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, scriptKind)
+    const result = emptyParsedFile(filePath, language, this.name, this.version, content)
+    const symbolStack: string[] = []
+
+    const addImport = (item: ImportInfo) => result.imports.push(item)
+    const addExport = (item: ExportInfo) => result.exports.push(item)
+    const addSymbol = (node: ts.Node, name: string, kind: SymbolInfo["kind"], exported = false, signature?: string) => {
+      const parent = symbolStack.at(-1)
+      const qualifiedName = parent ? `${parent}.${name}` : name
+      result.symbols.push({ name, qualified_name: qualifiedName, kind, parent, signature, range: symbolRange(node, source), exported })
+      if (exported) addExport({ name, kind: "named", range: symbolRange(node, source) })
+      return qualifiedName
+    }
+
+    const visit = (node: ts.Node): void => {
+      if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+        const names: string[] = []
+        const clause = node.importClause
+        if (clause?.name) names.push(clause.name.text)
+        if (clause?.namedBindings) {
+          if (ts.isNamespaceImport(clause.namedBindings)) names.push(`* as ${clause.namedBindings.name.text}`)
+          else for (const element of clause.namedBindings.elements) names.push(element.name.text)
+        }
+        addImport({ source: node.moduleSpecifier.text, names, kind: "import", range: symbolRange(node, source), resolution_status: "unresolved" })
+      }
+
+      if (ts.isExportDeclaration(node)) {
+        const sourceName = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : undefined
+        if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+          for (const element of node.exportClause.elements) addExport({ name: element.name.text, source: sourceName, kind: sourceName ? "reexport" : "named", range: symbolRange(element, source) })
+        } else if (sourceName) addExport({ name: "*", source: sourceName, kind: "reexport", range: symbolRange(node, source) })
+      }
+      if (ts.isExportAssignment(node)) {
+        addExport({ name: "default", source: textOf(node.expression, source), kind: "default", range: symbolRange(node, source) })
+      }
+
+      if (ts.isClassDeclaration(node) && node.name) {
+        const qualified = addSymbol(node, node.name.text, "class", isExported(node))
+        symbolStack.push(qualified)
+        const heritage = node.heritageClauses || []
+        for (const clause of heritage) for (const type of clause.types) {
+          const target = textOf(type.expression, source)
+          result.relations.push({ type: clause.token === ts.SyntaxKind.ImplementsKeyword ? "implements" : "extends", from: qualified, to: target, range: symbolRange(type, source), confidence: 1 })
+        }
+        for (const member of node.members) visit(member)
+        symbolStack.pop()
+        return
+      }
+      if (ts.isInterfaceDeclaration(node) && node.name) {
+        addSymbol(node, node.name.text, "interface", isExported(node))
+        return
+      }
+      if (ts.isTypeAliasDeclaration(node)) {
+        addSymbol(node, node.name.text, "type", isExported(node), textOf(node.type, source))
+        return
+      }
+      if (ts.isEnumDeclaration(node)) {
+        addSymbol(node, node.name.text, "enum", isExported(node))
+        return
+      }
+      if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
+        addSymbol(node, node.name.text, "module", isExported(node))
+        return
+      }
+      let scopedSymbol: string | undefined
+      if (ts.isFunctionDeclaration(node) && node.name) {
+        scopedSymbol = addSymbol(node, node.name.text, "function", isExported(node), textOf(node, source).split("{")[0].trim())
+      } else if (ts.isMethodDeclaration(node) && node.name) {
+        scopedSymbol = addSymbol(node, textOf(node.name, source), "method", isExported(node), textOf(node, source).split("{")[0].trim())
+      } else if (ts.isPropertyDeclaration(node) && node.name) {
+        addSymbol(node, textOf(node.name, source), "field", isExported(node))
+      } else if (ts.isVariableStatement(node)) {
+        for (const declaration of node.declarationList.declarations) if (ts.isIdentifier(declaration.name)) {
+          const value = declaration.initializer
+          const kind = value && (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) ? "function" : "variable"
+          addSymbol(declaration, declaration.name.text, kind, isExported(node), value ? textOf(value, source).split("=>")[0].trim() : undefined)
+        }
+      }
+
+      if (scopedSymbol) symbolStack.push(scopedSymbol)
+      if (ts.isCallExpression(node)) {
+        const callee = ts.isIdentifier(node.expression) ? node.expression.text : ts.isPropertyAccessExpression(node.expression) ? node.expression.name.text : ""
+        const first = node.arguments[0]
+        if (["describe", "test", "it", "specify"].includes(callee) && first && ts.isStringLiteral(first)) result.test_names.push(first.text)
+        const current = symbolStack.at(-1)
+        if (current && callee) result.relations.push({ type: "calls", from: current, to: callee, range: symbolRange(node, source), confidence: 0.8 })
+      }
+      ts.forEachChild(node, visit)
+      if (scopedSymbol) symbolStack.pop()
+    }
+
+    for (const statement of source.statements) visit(statement)
+    const parseDiagnostics = (source as ts.SourceFile & { parseDiagnostics?: ts.Diagnostic[] }).parseDiagnostics || []
+    const hasParseError = parseDiagnostics.length > 0
+    if (hasParseError) {
+      result.confidence = 0.8
+      for (const diagnostic of parseDiagnostics) {
+        const start = diagnostic.start || 0
+        result.diagnostics.push({ message: ts.flattenDiagnosticMessageText(diagnostic.messageText, " "), severity: "warning", range: rangeFromOffsets(content, start, start + (diagnostic.length || 1)) })
+      }
+    }
+    // Ensure the parser always emits a stable identity even for empty files.
+    result.package_name = basename(filePath)
+    result.content_hash = contentHash(content)
+    return result
+  }
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import { createSddTools } from "./opencode/tools.js"
+import { createSddHooks } from "./opencode/hooks.js"
+
+const SddPlugin: Plugin = async (_ctx) => {
+  const tools = createSddTools()
+  const hooks = createSddHooks()
+
+  return {
+    tool: tools,
+    ...hooks,
+  }
+}
+
+export default {
+  id: "opencode-telos",
+  server: SddPlugin,
+}
+
+export { createMcpServer } from "./mcp/server.js"
+export { SddDashboardServer } from "./server/server.js"
+export { analyzeCodebase } from "./code-intelligence/analyzer.js"