opencode-telos 1.0.0

package/src/sdd/drift/detector.ts

@@ -0,0 +1,465 @@
+import type { KnowledgeGraph, FileNode, ChangeNode } from "../domain/types.js"
+import { getNode, getNodesByType } from "../graph/engine.js"
+import { existsSync, readFileSync } from "fs"
+import { join } from "path"
+import { detectAllSignals, formatDriftSignals } from "./signals.js"
+import type { DriftSignals, DuplicateDetectionOptions } from "./signals.js"
+import { getExclusionSets, isNodeExcludedOrDeprecated, isFileWhitelistedPattern } from "./exclusion.js"
+import { hasPersistenceMapping } from "../validation/validator.js"
+import { validateGraphIntegrity } from "../graph/integrity-guard.js"
+import { parseWithCache, loadAstCache, saveAstCache } from "../../code-intelligence/ast/cache.js"
+
+export interface DriftDetectionResult {
+  has_drift: boolean
+  missing_files: MissingFileDrift[]
+  untracked_files: UntrackedFileDrift[]
+  spec_code_mismatches: SpecCodeMismatch[]
+  signals?: DriftSignals
+}
+
+export interface MissingFileDrift {
+  node_id: string
+  file_path: string
+  expected_by: string
+}
+
+export interface UntrackedFileDrift {
+  file_path: string
+  full_path?: string
+  severity?: "info" | "warning" | "error"
+  suggestion: string
+}
+
+export interface SpecCodeMismatch {
+  node_id: string
+  description: string
+  severity: "high" | "medium" | "low"
+}
+
+
+
+export function detectDrift(
+  graph: KnowledgeGraph,
+  projectDir: string,
+  options?: DuplicateDetectionOptions,
+): DriftDetectionResult {
+  const result: DriftDetectionResult = {
+    has_drift: false,
+    missing_files: [],
+    untracked_files: [],
+    spec_code_mismatches: [],
+  }
+
+  // Pre-compute sets of nodes that should be excluded from drift detection.
+  // Nodes removed via ChangeNode or deprecated should NOT trigger drift.
+  const { removed: removedNodeIds, deprecated: deprecatedNodeIds } = getExclusionSets(graph)
+
+  detectMissingFiles(graph, projectDir, result, removedNodeIds, deprecatedNodeIds)
+  detectUntrackedFiles(graph, projectDir, result, removedNodeIds, deprecatedNodeIds)
+  detectSpecCodeMismatches(graph, projectDir, result, removedNodeIds, deprecatedNodeIds)
+  detectAstFileMismatches(graph, projectDir, result, removedNodeIds, deprecatedNodeIds)
+
+  // Filter out whitelisted files from drift results
+  result.missing_files = result.missing_files.filter(
+    (f) => !isFileWhitelistedPattern(projectDir, f.file_path),
+  )
+  result.untracked_files = result.untracked_files.filter(
+    (f) => !isFileWhitelistedPattern(projectDir, f.file_path),
+  )
+  result.spec_code_mismatches = result.spec_code_mismatches.filter(
+    (m) => !isFileWhitelistedPattern(projectDir, m.node_id),
+  )
+
+  // Anti-bypass: check for out-of-band graph modifications
+  try {
+    const tamperResult = validateGraphIntegrity(projectDir, graph)
+    if (tamperResult.tampered) {
+      result.spec_code_mismatches.push({
+        node_id: "__tamper__",
+        description: tamperResult.reason || "Graph modified outside SDD workflow",
+        severity: "high",
+      })
+    }
+  } catch {}
+
+  // Re-evaluate has_drift after filtering
+  result.has_drift =
+    result.missing_files.length > 0 ||
+    result.untracked_files.length > 0 ||
+    result.spec_code_mismatches.length > 0 ||
+    (result.signals?.total_signals ?? 0) > 0
+
+  const signals = detectAllSignals(graph, projectDir, options)
+
+  // Filter out whitelisted architecture violations from signals
+  signals.architecture_violations = signals.architecture_violations.filter(
+    (v) => !isFileWhitelistedPattern(projectDir, v.file),
+  )
+  // Recalculate total_signals after filtering
+  signals.total_signals =
+    signals.mutant_duplicates.length +
+    signals.architecture_violations.length +
+    signals.pattern_fragmentation.length +
+    signals.temporal_volatility.length
+
+  result.signals = signals
+
+  result.has_drift =
+    result.missing_files.length > 0 ||
+    result.untracked_files.length > 0 ||
+    result.spec_code_mismatches.length > 0 ||
+    signals.total_signals > 0
+
+  return result
+}
+
+/** Compare persisted AST evidence with the current source without executing it. */
+function detectAstFileMismatches(
+  graph: KnowledgeGraph,
+  projectDir: string,
+  result: DriftDetectionResult,
+  removedNodeIds: Set<string>,
+  deprecatedNodeIds: Set<string>,
+): void {
+  const cache = loadAstCache(projectDir)
+  const fileNodes = getNodesByType<FileNode>(graph, "file")
+  for (const fileNode of fileNodes) {
+    if (isNodeExcludedOrDeprecated(fileNode.id, fileNode.status, removedNodeIds, deprecatedNodeIds)) continue
+    const filePath = fileNode.metadata.path
+    if (!filePath || !existsSync(join(projectDir, filePath))) continue
+    try {
+      const content = readFileSync(join(projectDir, filePath), "utf-8")
+      const parsed = parseWithCache(projectDir, join(projectDir, filePath), content, cache)
+      const metadata = fileNode.metadata as Record<string, unknown>
+      if (typeof metadata.content_hash === "string" && metadata.content_hash !== parsed.content_hash) {
+        result.spec_code_mismatches.push({ node_id: fileNode.id, description: `AST content fingerprint changed for ${filePath}`, severity: "high" })
+      }
+      const expected = Array.isArray(metadata.expected_symbols) ? metadata.expected_symbols : Array.isArray(metadata.symbols) ? metadata.symbols : []
+      if (expected.length > 0) {
+        const actual = new Set(parsed.symbols.map((symbol) => symbol.qualified_name))
+        for (const value of expected) {
+          if (typeof value === "string" && !actual.has(value)) result.spec_code_mismatches.push({ node_id: fileNode.id, description: `Expected AST symbol ${value} is missing from ${filePath}`, severity: "high" })
+        }
+      }
+      if (parsed.analysis_source === "fallback") result.spec_code_mismatches.push({ node_id: fileNode.id, description: `File ${filePath} was analyzed with a low-confidence fallback parser`, severity: "low" })
+    } catch (error) {
+      result.spec_code_mismatches.push({ node_id: fileNode.id, description: `Could not parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`, severity: "medium" })
+    }
+  }
+  saveAstCache(projectDir, cache)
+}
+
+function detectMissingFiles(
+  graph: KnowledgeGraph,
+  projectDir: string,
+  result: DriftDetectionResult,
+  removedNodeIds: Set<string>,
+  deprecatedNodeIds: Set<string>,
+): void {
+  const fileNodes = getNodesByType<FileNode>(graph, "file")
+  for (const fileNode of fileNodes) {
+    // Skip files that were removed by a completed change or deprecated
+    if (isNodeExcludedOrDeprecated(fileNode.id, fileNode.status, removedNodeIds, deprecatedNodeIds)) continue
+
+    const filePath = fileNode.metadata.path
+    if (!filePath) continue
+    const fullPath = join(projectDir, filePath)
+    if (existsSync(fullPath)) continue
+
+    // ── Fuzzy path matching: try to find the file in nearby locations ──
+    const fuzzyMatch = findFuzzyPathMatch(filePath, projectDir)
+    if (fuzzyMatch) {
+      // File exists but in a different path — suggest auto-heal
+      result.missing_files.push({
+        node_id: fileNode.id,
+        file_path: filePath,
+        expected_by: `File node ${fileNode.id} (exists at: ${fuzzyMatch} — consider updating path)`,
+      })
+    } else {
+      result.missing_files.push({
+        node_id: fileNode.id,
+        file_path: filePath,
+        expected_by: `File node ${fileNode.id}`,
+      })
+    }
+  }
+
+  // Also check task-referenced files
+  const taskNodes = graph.nodes.filter((n) => n.type === "task")
+  for (const task of taskNodes) {
+    // Skip tasks removed by a completed change or deprecated
+    if (isNodeExcludedOrDeprecated(task.id, task.status, removedNodeIds, deprecatedNodeIds)) continue
+
+    const meta = task.metadata as Record<string, unknown>
+    if (Array.isArray(meta.files)) {
+      for (const file of meta.files) {
+        if (typeof file === "string") {
+          const fullPath = join(projectDir, file)
+          if (!existsSync(fullPath)) {
+            result.missing_files.push({
+              node_id: task.id,
+              file_path: file,
+              expected_by: `Task ${task.id}`,
+            })
+          }
+        }
+      }
+    }
+  }
+}
+
+function detectUntrackedFiles(
+  graph: KnowledgeGraph,
+  projectDir: string,
+  result: DriftDetectionResult,
+  removedNodeIds: Set<string>,
+  deprecatedNodeIds: Set<string>,
+): void {
+  const trackedPaths = new Set<string>()
+  const fileNodes = getNodesByType<FileNode>(graph, "file")
+  for (const fn of fileNodes) {
+    // Skip files removed by change or deprecated — their paths should NOT
+    // be added to trackedPaths, so if the file still exists on disk it
+    // will correctly appear as untracked (or be handled by change nodes).
+    if (isNodeExcludedOrDeprecated(fn.id, fn.status, removedNodeIds, deprecatedNodeIds)) continue
+    if (fn.metadata.path) trackedPaths.add(fn.metadata.path)
+  }
+
+  const taskNodes = graph.nodes.filter((n) => n.type === "task")
+  for (const task of taskNodes) {
+    if (isNodeExcludedOrDeprecated(task.id, task.status, removedNodeIds, deprecatedNodeIds)) continue
+    const meta = task.metadata as Record<string, unknown>
+    if (Array.isArray(meta.files)) {
+      for (const f of meta.files) {
+        if (typeof f === "string") trackedPaths.add(f)
+      }
+    }
+  }
+
+  // Only track files from DRAFT/PROPOSED/APPROVED changes (pending changes)
+  // COMPLETED changes already had their affected files processed
+  const changeNodes = graph.nodes.filter((n) => n.type === "change") as ChangeNode[]
+  for (const change of changeNodes) {
+    if (["DRAFT", "PROPOSED", "APPROVED"].includes(change.status)) {
+      if (change.metadata.affected_files) {
+        for (const f of change.metadata.affected_files) {
+          trackedPaths.add(f)
+        }
+      }
+    }
+  }
+
+  const sourceExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".rb", ".vue", ".svelte"]
+  const excludePatterns = ["node_modules", ".sdd", "dist", "build", ".git", ".opencode", "__pycache__", "vendor"]
+
+  function scanDirectory(dir: string, relativePath: string = ""): void {
+    let entries: string[]
+    try {
+      entries = require("fs").readdirSync(dir)
+    } catch {
+      return
+    }
+
+    for (const entry of entries) {
+      if (excludePatterns.some(p => entry === p || entry.startsWith(p))) continue
+
+      const fullPath = `${dir}/${entry}`
+      const relPath = relativePath ? `${relativePath}/${entry}` : entry
+
+      let stat
+      try {
+        stat = require("fs").statSync(fullPath)
+      } catch {
+        continue
+      }
+
+      if (stat.isDirectory()) {
+        scanDirectory(fullPath, relPath)
+      } else if (sourceExtensions.some(ext => entry.endsWith(ext))) {
+        if (!trackedPaths.has(relPath) && !trackedPaths.has(fullPath)) {
+          result.untracked_files = result.untracked_files || []
+          // Infer what this file might implement based on name/path
+          const inferredEntity = inferEntityFromFile(relPath, graph)
+          const suggestion = inferredEntity
+            ? `File likely implements "${inferredEntity}" — use sdd.add_node to create FileNode, then sdd.add_relationship to link it`
+            : "Arquivo não rastreado pelo SDD. Considere adicionar um FileNode."
+          result.untracked_files.push({
+            file_path: relPath,
+            full_path: fullPath,
+            severity: "info",
+            suggestion,
+          })
+          if (!result.has_drift) {
+            result.has_drift = true
+          }
+        }
+      }
+    }
+  }
+
+  scanDirectory(projectDir)
+}
+
+/**
+ * Try to infer which entity/feature a file implements based on its name.
+ */
+function inferEntityFromFile(filePath: string, graph: KnowledgeGraph): string | null {
+  const fileName = filePath.split("/").pop()?.toLowerCase().replace(/\.[^.]+$/, "") || ""
+  if (fileName.length < 3) return null
+
+  // Check against entity names
+  const entities = graph.nodes.filter(n => n.type === "entity")
+  for (const entity of entities) {
+    const entityName = entity.name.toLowerCase()
+    if (fileName.includes(entityName) || entityName.includes(fileName)) {
+      return entity.name
+    }
+  }
+
+  // Check against feature names
+  const features = graph.nodes.filter(n => n.type === "feature")
+  for (const feature of features) {
+    const featureName = feature.name.toLowerCase()
+    if (fileName.includes(featureName) || featureName.includes(fileName)) {
+      return feature.name
+    }
+  }
+
+  return null
+}
+
+function detectSpecCodeMismatches(
+  graph: KnowledgeGraph,
+  _projectDir: string,
+  result: DriftDetectionResult,
+  removedNodeIds: Set<string>,
+  deprecatedNodeIds: Set<string>,
+): void {
+  // Check entity nodes for corresponding persistence (multiple strategies)
+  // Uses the same logic as hasPersistenceMapping in validation/validator.ts
+  const entities = graph.nodes.filter((n) => n.type === "entity")
+  for (const entity of entities) {
+    // Skip entities removed by change or deprecated
+    if (isNodeExcludedOrDeprecated(entity.id, entity.status, removedNodeIds, deprecatedNodeIds)) continue
+
+    if (!hasPersistenceMapping(entity, graph) && entities.length > 0) {
+      result.spec_code_mismatches.push({
+        node_id: entity.id,
+        description: `Entity ${entity.id} has no persistence mapping`,
+        severity: "medium",
+      })
+    }
+  }
+
+  // Check API nodes for endpoint completeness
+  const apis = graph.nodes.filter((n) => n.type === "api")
+  for (const api of apis) {
+    // Skip APIs removed by change or deprecated
+    if (isNodeExcludedOrDeprecated(api.id, api.status, removedNodeIds, deprecatedNodeIds)) continue
+
+    const endpoints = graph.relationships
+      .filter((r) => r.from === api.id && r.type === "contains")
+      .map((r) => getNode(graph, r.to))
+      .filter((n) => n?.type === "endpoint")
+
+    if (endpoints.length === 0) {
+      result.spec_code_mismatches.push({
+        node_id: api.id,
+        description: `API ${api.id} has no endpoints defined`,
+        severity: "low",
+      })
+    }
+  }
+}
+
+/**
+ * Try to find a file in a nearby location when the expected path doesn't exist.
+ * Handles common structural changes like:
+ * - src/validators.ts → src/fields/validators/index.ts
+ * - src/schema.ts → src/schema/index.ts
+ * - src/components/X.ts → src/components/X/index.ts
+ */
+function findFuzzyPathMatch(expectedPath: string, projectDir: string): string | null {
+  const segments = expectedPath.split("/")
+  const filename = segments[segments.length - 1]
+  const nameWithoutExt = filename.replace(/\.[^.]+$/, "")
+
+  // Strategy 1: Check if file exists as index in a subdirectory
+  // e.g., "src/validators.ts" → try "src/validators/index.ts"
+  const withoutExt = expectedPath.replace(/\.[^.]+$/, "")
+  const indexCandidates = [
+    `${withoutExt}/index.ts`,
+    `${withoutExt}/index.tsx`,
+    `${withoutExt}/index.js`,
+    `${withoutExt}/index.jsx`,
+  ]
+  for (const candidate of indexCandidates) {
+    if (existsSync(join(projectDir, candidate))) return candidate
+  }
+
+  // Strategy 2: Search for files with the same name in parent/sibling directories
+  const dir = segments.slice(0, -1).join("/")
+  const parentDir = segments.slice(0, -2).join("/")
+  if (parentDir) {
+    try {
+      const entries = require("fs").readdirSync(join(projectDir, parentDir), { withFileTypes: true })
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        const candidateDir = `${parentDir}/${entry.name}`
+        const candidatePath = `${candidateDir}/${filename}`
+        if (existsSync(join(projectDir, candidatePath))) return candidatePath
+        // Also check index files in subdirectories
+        const idxCandidates = [
+          `${candidateDir}/${nameWithoutExt}/index.ts`,
+          `${candidateDir}/${nameWithoutExt}/index.tsx`,
+        ]
+        for (const idx of idxCandidates) {
+          if (existsSync(join(projectDir, idx))) return idx
+        }
+      }
+    } catch {
+      // skip
+    }
+  }
+
+  // Strategy 3: Check one level up in directory tree
+  if (segments.length > 2) {
+    const parentPath = segments.slice(0, -2).concat(filename).join("/")
+    if (existsSync(join(projectDir, parentPath))) return parentPath
+  }
+
+  return null
+}
+
+export function formatDriftReport(result: DriftDetectionResult): string {
+  const lines: string[] = []
+
+  if (!result.has_drift) {
+    lines.push("✅ No drift detected. SDD and code are in sync.\n")
+    return lines.join("\n")
+  }
+
+  lines.push("⚠️ Drift Detected\n")
+
+  if (result.missing_files.length > 0) {
+    lines.push(`### Missing Files (${result.missing_files.length})`)
+    for (const missing of result.missing_files) {
+      lines.push(`- [${missing.node_id}] ${missing.file_path} (expected by: ${missing.expected_by})`)
+    }
+    lines.push("")
+  }
+
+  if (result.spec_code_mismatches.length > 0) {
+    lines.push(`### Specification Mismatches (${result.spec_code_mismatches.length})`)
+    for (const mismatch of result.spec_code_mismatches) {
+      lines.push(`- [${mismatch.node_id}] ${mismatch.description} (severity: ${mismatch.severity})`)
+    }
+    lines.push("")
+  }
+
+  if (result.signals && result.signals.total_signals > 0) {
+    lines.push(formatDriftSignals(result.signals))
+  }
+
+  return lines.join("\n")
+}

package/src/sdd/drift/exclusion.ts

@@ -0,0 +1,223 @@
+import type { KnowledgeGraph, ChangeNode } from "../domain/types.js"
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs"
+import { join, dirname } from "path"
+
+/**
+ * Collects all node IDs that were removed by completed or approved changes.
+ * Nodes removed via ChangeNode should not be flagged as drift or cause
+ * false positives in validation, coverage, contradictions, etc.
+ */
+export function getRemovedNodeIds(graph: KnowledgeGraph): Set<string> {
+  const removed = new Set<string>()
+  const changes = graph.nodes.filter(
+    (n): n is ChangeNode =>
+      n.type === "change" &&
+      ["COMPLETED", "APPROVED", "IMPLEMENTED"].includes(n.status),
+  )
+  for (const change of changes) {
+    const meta = change.metadata as ChangeNode["metadata"]
+    if (Array.isArray(meta.removed_nodes)) {
+      for (const id of meta.removed_nodes) {
+        removed.add(id)
+      }
+    }
+  }
+  return removed
+}
+
+/**
+ * Collects all node IDs that were deprecated via DeprecationNode relationships.
+ */
+export function getDeprecatedNodeIds(graph: KnowledgeGraph): Set<string> {
+  const deprecated = new Set<string>()
+  const deprecationNodes = graph.nodes.filter((n) => n.type === "deprecation")
+  for (const dep of deprecationNodes) {
+    const targets = graph.relationships
+      .filter((r) => r.from === dep.id && r.type === "deprecates")
+      .map((r) => r.to)
+    for (const id of targets) {
+      deprecated.add(id)
+    }
+  }
+  return deprecated
+}
+
+/**
+ * Checks if a node should be excluded, also considering DEPRECATED status.
+ */
+export function isNodeExcludedOrDeprecated(
+  nodeId: string,
+  status: string,
+  removedIds: Set<string>,
+  deprecatedIds: Set<string>,
+): boolean {
+  return (
+    status === "DEPRECATED" ||
+    removedIds.has(nodeId) ||
+    deprecatedIds.has(nodeId)
+  )
+}
+
+/**
+ * Convenience: pre-compute both sets at once.
+ */
+export function getExclusionSets(graph: KnowledgeGraph): {
+  removed: Set<string>
+  deprecated: Set<string>
+} {
+  return {
+    removed: getRemovedNodeIds(graph),
+    deprecated: getDeprecatedNodeIds(graph),
+  }
+}
+
+// ── Drift Whitelist ─────────────────────────────────────────────────
+
+const DRIFT_WHITELIST_FILE = ".sdd/drift-whitelist.json"
+
+export interface DriftWhitelistEntry {
+  file_path: string
+  reason: string
+  added_at: string
+  added_by?: string
+}
+
+export interface DriftWhitelist {
+  version: number
+  entries: DriftWhitelistEntry[]
+}
+
+/**
+ * Load the drift whitelist from disk.
+ */
+export function loadDriftWhitelist(projectDir: string): DriftWhitelist {
+  const path = join(projectDir, DRIFT_WHITELIST_FILE)
+  if (!existsSync(path)) return { version: 1, entries: [] }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as DriftWhitelist
+  } catch {
+    return { version: 1, entries: [] }
+  }
+}
+
+/**
+ * Save the drift whitelist to disk.
+ */
+export function saveDriftWhitelist(projectDir: string, whitelist: DriftWhitelist): void {
+  const path = join(projectDir, DRIFT_WHITELIST_FILE)
+  const dir = dirname(path)
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  writeFileSync(path, JSON.stringify(whitelist, null, 2), "utf-8")
+}
+
+/**
+ * Add a file to the drift whitelist.
+ */
+export function addToDriftWhitelist(
+  projectDir: string,
+  filePath: string,
+  reason: string,
+  addedBy?: string,
+): DriftWhitelist {
+  const whitelist = loadDriftWhitelist(projectDir)
+  const normalizedPath = filePath.replace(/^\.\//, "")
+
+  // Don't add duplicates
+  if (!whitelist.entries.some(e => e.file_path === normalizedPath)) {
+    whitelist.entries.push({
+      file_path: normalizedPath,
+      reason,
+      added_at: new Date().toISOString(),
+      added_by: addedBy,
+    })
+    saveDriftWhitelist(projectDir, whitelist)
+  }
+
+  return whitelist
+}
+
+/**
+ * Remove a file from the drift whitelist.
+ */
+export function removeFromDriftWhitelist(
+  projectDir: string,
+  filePath: string,
+): DriftWhitelist {
+  const whitelist = loadDriftWhitelist(projectDir)
+  const normalizedPath = filePath.replace(/^\.\//, "")
+  whitelist.entries = whitelist.entries.filter(e => e.file_path !== normalizedPath)
+  saveDriftWhitelist(projectDir, whitelist)
+  return whitelist
+}
+
+/**
+ * Check if a file path matches any whitelist pattern (supports wildcards).
+ * E.g., "src/validators/*" matches all files in src/validators/
+ */
+export function isFileWhitelistedPattern(projectDir: string, filePath: string): boolean {
+  const whitelist = loadDriftWhitelist(projectDir)
+  const normalizedPath = filePath.replace(/^\.\//, "")
+
+  for (const entry of whitelist.entries) {
+    // Exact match
+    if (entry.file_path === normalizedPath) return true
+
+    // Recursive wildcard: apps/**, packages/**, **/*.ts, etc.
+    if (entry.file_path.endsWith("/**")) {
+      const prefix = entry.file_path.slice(0, -3)
+      if (normalizedPath.startsWith(prefix + "/") || normalizedPath === prefix) return true
+    }
+
+    // Single-level wildcard: src/validators/*
+    if (entry.file_path.endsWith("/*") && !entry.file_path.endsWith("/**")) {
+      const prefix = entry.file_path.slice(0, -2)
+      if (normalizedPath.startsWith(prefix + "/") || normalizedPath === prefix) return true
+    }
+
+    // Directory match (ends with /)
+    if (entry.file_path.endsWith("/")) {
+      if (normalizedPath.startsWith(entry.file_path)) return true
+    }
+
+    // Glob wildcard in filename: **/*.ts, *.tsx, src/**/*.ts
+    if (entry.file_path.includes("*")) {
+      const regex = globToRegex(entry.file_path)
+      if (regex.test(normalizedPath)) return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Convert a glob pattern to a RegExp.
+ * Supports double-star and single-star patterns.
+ */
+function globToRegex(glob: string): RegExp {
+  // Process segments separated by /
+  const segments = glob.split("/")
+  const regexParts: string[] = []
+
+  for (const seg of segments) {
+    if (seg === "**") {
+      // ** matches any number of path segments
+      regexParts.push(".*")
+    } else if (seg === "*") {
+      // Single * matches within one segment
+      regexParts.push("[^/]+")
+    } else if (seg.includes("*")) {
+      // Mixed segment like *.ts or tsx-*.test
+      const escaped = seg.replace(/\./g, "\\.")
+      const inner = escaped.replace(/\*/g, "[^/]*")
+      regexParts.push(inner)
+    } else {
+      // Literal segment
+      const escaped = seg.replace(/\./g, "\\.")
+      regexParts.push(escaped)
+    }
+  }
+
+  // Join with \/ to match path separators
+  const pattern = regexParts.join("\\/")
+  return new RegExp("^" + pattern + "$")
+}