code-auditor-mcp 5.0.2 → 5.3.3

package/dist/languages/go/analyzer-src/dataaccess.go

@@ -1,388 +0,0 @@
-package analyzer
-
-import (
-	"go/ast"
-	"go/token"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// runDataAccessAnalysis analyzes database-access patterns on `database/sql`,
-// `sqlx`, and GORM (`Raw`) method calls. It is the Go-subprocess counterpart of the TypeScript
-// `UniversalDataAccessAnalyzer` + schema Stage-4 reducer, emitting the same
-// bare rule IDs at the same ledger severities.
-//
-// Tenancy is declared, not guessed. The TypeScript pipeline resolves "which
-// tables require an org/tenant filter" from three tiers — explicit
-// `orgFilterTables` (config), configured `schemas` tables carrying a
-// tenant-scoping column, and DDL migrations (`CREATE TABLE` columns) — via
-// `buildOrgFilterTierSet`. This subprocess is syntax-only and does not read the
-// project config or DDL itself, so the resolved tiers are handed to it in
-// `AnalysisOptions`:
-//
-//   - `orgFilterTables` — the tenant-scoped tables (all three tiers, lowercased)
-//     that drive `missing-org-filter`.
-//   - `knownTables` — the known-table catalog (DDL tables + configured schemas +
-//     explicit tables) that drives `unknown-table`.
-//   - `orgFilterColumns` — the tenant-scoping column names that count as a
-//     tenant predicate, defaulting to org_id/tenant_id/organization_id/
-//     workspace_id (the same default as the TS pipeline).
-//
-// An earlier revision hardcoded `tenantTables`/`knownTables` word lists as a
-// substitute for declared tenancy — the Spec 44 English-name fallback the TS
-// side had already deleted on purpose. That made `missing-org-filter` fire on
-// `users`/`projects`/`orders` whether or not the project declared them
-// multi-tenant, and stay silent on a genuinely tenant-scoped table whose name
-// was absent from the list. Declared tenancy removes both errors.
-
-// tableExtractRe matches `FROM <table>` / `INTO <table>` / `UPDATE <table>`
-// (optionally backtick/double/single-quoted, optionally schema-prefixed).
-var tableExtractRe = regexp.MustCompile(`(?i)\b(?:from|into|update)\s+[` + "`\"']?([A-Za-z_][A-Za-z0-9_.]*)")
-
-// whereRe matches a row-limiting clause (WHERE/HAVING/LIMIT).
-var whereRe = regexp.MustCompile(`(?i)\b(where|having|limit)\b`)
-
-// defaultOrgFilterColumns are the tenant-scoping column names assumed when the
-// caller supplies none. Mirrors DEFAULT_ORG_FILTER_COLUMNS on the TS side.
-var defaultOrgFilterColumns = []string{"org_id", "tenant_id", "organization_id", "workspace_id"}
-
-func (a *Analyzer) runDataAccessAnalysis() []Violation {
-	var violations []Violation
-
-	tenantTables := a.declaredTenantTables()
-	knownTables := a.declaredKnownTables()
-	tenantPredRe := a.tenantPredicateRegex()
-
-	for filePath, file := range a.parser.files {
-		ast.Inspect(file, func(n ast.Node) bool {
-			call, ok := n.(*ast.CallExpr)
-			if !ok {
-				return true
-			}
-			method, sqlArgIndex, isDB := dbMethodName(call)
-			if !isDB || sqlArgIndex < 0 || sqlArgIndex >= len(call.Args) {
-				return true
-			}
-			sqlExpr := call.Args[sqlArgIndex]
-
-			// sql-injection-risk: a dynamically-constructed SQL string is an
-			// injection surface; a raw string literal with `$1` placeholders is
-			// not. The dynamic case returns early — its table name is not
-			// resolvable, so the table-based rules below cannot apply.
-			if isDynamicSQL(sqlExpr) {
-				if !containsSQLVerb(sqlFormatString(sqlExpr)) {
-					return true
-				}
-				pos := a.parser.fileSet.Position(call.Pos())
-				violations = append(violations, Violation{
-					File:     filePath,
-					Line:     pos.Line,
-					Severity: "critical",
-					Message:  "SQL query is built with string formatting instead of parameterized placeholders",
-					Details: map[string]interface{}{
-						"method": method,
-					},
-					Suggestion: "Use $1/$2 placeholders and pass the values as separate arguments",
-					Analyzer:   "go",
-					Rule:       "sql-injection-risk",
-				})
-				return true
-			}
-
-			sqlText := literalString(sqlExpr)
-			if sqlText == "" {
-				// A variable-held SQL string: neither provably static nor
-				// provably dynamic. Leave it alone rather than guess.
-				return true
-			}
-
-			verb := sqlVerb(sqlText)
-			table := extractTable(sqlText)
-			if table == "" {
-				return true
-			}
-
-			// unknown-table: a recognized-name near-miss (`user` → `users`).
-			if near, known := nearMissTable(knownTables, table); !known && near != "" {
-				pos := a.parser.fileSet.Position(call.Pos())
-				violations = append(violations, Violation{
-					File:     filePath,
-					Line:     pos.Line,
-					Severity: "critical",
-					Message:  "Reference to unknown table \"" + table + "\" (did you mean \"" + near + "\"?)",
-					Details: map[string]interface{}{
-						"table":      table,
-						"suggestion": near,
-					},
-					Suggestion: "Rename the table reference \"" + table + "\" to \"" + near + "\"",
-					Analyzer:   "go",
-					Rule:       "unknown-table",
-				})
-			}
-
-			hasWhere := whereRe.MatchString(sqlText)
-			hasTenantPred := tenantPredRe.MatchString(sqlText)
-
-			// missing-org-filter: a row-affecting query (SELECT/UPDATE/DELETE) on
-			// a tenant table with no tenant predicate. INSERT is excluded — an
-			// insert does not filter existing rows; it should carry the tenant
-			// column as a value, not a predicate.
-			if tenantTables[table] && verb != "INSERT" && !hasTenantPred {
-				pos := a.parser.fileSet.Position(call.Pos())
-				violations = append(violations, Violation{
-					File:     filePath,
-					Line:     pos.Line,
-					Severity: "critical",
-					Message:  "Query on \"" + table + "\" has no organization/tenant predicate",
-					Details: map[string]interface{}{
-						"table":  table,
-						"method": method,
-					},
-					Suggestion: "Add the tenant column (organization_id / org_id) to the WHERE predicate",
-					Analyzer:   "go",
-					Rule:       "missing-org-filter",
-				})
-			}
-
-			// unfiltered-query: a write (INSERT/UPDATE/DELETE) with no
-			// WHERE/HAVING/LIMIT. INSERT counts as a write here — the corpus pins
-			// it — whereas the TS rule scopes writes to DELETE/UPDATE; an
-			// unparameterized mass INSERT is the same "no filter" shape.
-			if isWriteVerb(verb) && !hasWhere {
-				pos := a.parser.fileSet.Position(call.Pos())
-				violations = append(violations, Violation{
-					File:     filePath,
-					Line:     pos.Line,
-					Severity: "high",
-					Message:  "Write query on \"" + table + "\" has no WHERE/HAVING/LIMIT",
-					Details: map[string]interface{}{
-						"table":  table,
-						"method": method,
-					},
-					Suggestion: "Add a WHERE/HAVING/LIMIT to scope the write",
-					Analyzer:   "go",
-					Rule:       "unfiltered-query",
-				})
-			}
-
-			return true
-		})
-	}
-
-	return violations
-}
-
-// dbMethodName reports whether the call is a `database/sql`, `sqlx`, or GORM
-// method invocation and returns the selector name plus the index of the
-// SQL-string argument within the call. The method set is the `database/sql`
-// query/exec/prepare surface, the `sqlx` wrapper surface, and GORM's `Raw`
-// (its one full-SQL literal method); it deliberately excludes `Close`,
-// `Commit`, `Rollback`, `Err`, and `Next`, which are not SQL-bearing.
-//
-// The SQL argument is not always arg[0], and getting the index wrong is a
-// silent no-op (the analyzer extracts the wrong expression, sees it is not a
-// string literal, and returns early). Two families carry the SQL later:
-//
-//   - **Context variants** (`QueryContext`, `ExecContext`, `QueryxContext`,
-//     `MustExecContext`, …) put `ctx context.Context` first, so the SQL is
-//     arg[1]. This is the canonical parameterized form since Go 1.8 — the
-//     overwhelmingly common shape in production code — so the index matters
-//     more here than for the bare forms.
-//   - **sqlx `Get`/`Select`** put the destination pointer before the SQL
-//     (`Get(dest, query, args…)`), so the SQL is arg[1]; with `ctx` it is
-//     arg[2] (`GetContext(ctx, dest, query, args…)`).
-func dbMethodName(call *ast.CallExpr) (string, int, bool) {
-	sel, ok := call.Fun.(*ast.SelectorExpr)
-	if !ok {
-		return "", -1, false
-	}
-	switch sel.Sel.Name {
-	// database/sql — SQL string is arg[0].
-	case "Query", "QueryRow", "Exec", "Prepare":
-		return sel.Sel.Name, 0, true
-	// database/sql Context — ctx first, SQL string is arg[1].
-	case "QueryContext", "QueryRowContext", "ExecContext", "PrepareContext":
-		return sel.Sel.Name, 1, true
-	// sqlx — SQL string is arg[0].
-	case "Queryx", "QueryRowx", "NamedExec", "NamedQuery", "MustExec":
-		return sel.Sel.Name, 0, true
-	// sqlx Context — ctx first, SQL string is arg[1].
-	case "QueryxContext", "QueryRowxContext", "NamedExecContext", "NamedQueryContext", "MustExecContext":
-		return sel.Sel.Name, 1, true
-	// sqlx — SQL string is arg[1] (after the destination pointer).
-	case "Get", "Select":
-		return sel.Sel.Name, 1, true
-	// sqlx — SQL string is arg[2] (after ctx + destination pointer).
-	case "GetContext", "SelectContext":
-		return sel.Sel.Name, 2, true
-	// GORM — `Raw(sql, values…)` is GORM's full-SQL literal method; SQL is
-	// arg[0]. GORM's `Exec`/`Select` are intentionally NOT listed here: `Exec`
-	// is already the database/sql case above, and GORM's `Select` takes a
-	// column list (`Select("name, age")`), not a full statement.
-	case "Raw":
-		return sel.Sel.Name, 0, true
-	}
-	return "", -1, false
-}
-
-// isDynamicSQL reports whether the SQL argument is constructed at runtime
-// (string formatting or concatenation) rather than a single string literal.
-func isDynamicSQL(expr ast.Expr) bool {
-	switch e := expr.(type) {
-	case *ast.BasicLit:
-		return false
-	case *ast.CallExpr:
-		// Any call producing the SQL (fmt.Sprintf, a query builder, …) is
-		// dynamic — its text is not a constant the analyzer can inspect.
-		return true
-	case *ast.BinaryExpr:
-		return e.Op == token.ADD
-	default:
-		// A bare identifier is a variable-held string: treated as static (not
-		// flagged), since there is no construction site to name as the risk.
-		return false
-	}
-}
-
-// literalString returns the unquoted value of a string literal, or "".
-func literalString(expr ast.Expr) string {
-	lit, ok := expr.(*ast.BasicLit)
-	if !ok || lit.Kind != token.STRING {
-		return ""
-	}
-	s, err := strconv.Unquote(lit.Value)
-	if err != nil {
-		return lit.Value
-	}
-	return s
-}
-
-// sqlFormatString returns the format string of a Sprintf-style call (its first
-// argument when that argument is a literal), else "".
-func sqlFormatString(expr ast.Expr) string {
-	call, ok := expr.(*ast.CallExpr)
-	if !ok || len(call.Args) == 0 {
-		return ""
-	}
-	return literalString(call.Args[0])
-}
-
-// containsSQLVerb reports whether a (possibly dynamic) SQL fragment contains a
-// DML keyword — the signal that a formatted string is actually SQL, not e.g.
-// a `fmt.Sprintf` of a display label passed as a query argument by accident.
-func containsSQLVerb(s string) bool {
-	up := strings.ToUpper(s)
-	return strings.Contains(up, "SELECT") ||
-		strings.Contains(up, "INSERT") ||
-		strings.Contains(up, "UPDATE") ||
-		strings.Contains(up, "DELETE") ||
-		strings.Contains(up, "FROM")
-}
-
-// sqlVerb returns the leading DML keyword of a SQL statement, or "".
-func sqlVerb(sql string) string {
-	up := strings.ToUpper(strings.TrimSpace(sql))
-	switch {
-	case strings.HasPrefix(up, "SELECT"):
-		return "SELECT"
-	case strings.HasPrefix(up, "INSERT"):
-		return "INSERT"
-	case strings.HasPrefix(up, "UPDATE"):
-		return "UPDATE"
-	case strings.HasPrefix(up, "DELETE"):
-		return "DELETE"
-	}
-	return ""
-}
-
-// extractTable returns the lowercased table name referenced by FROM/INTO/UPDATE,
-// or "". A schema prefix (`public.users`) is stripped to the bare name.
-func extractTable(sql string) string {
-	m := tableExtractRe.FindStringSubmatch(sql)
-	if m == nil {
-		return ""
-	}
-	table := m[1]
-	if idx := strings.LastIndexByte(table, '.'); idx >= 0 {
-		table = table[idx+1:]
-	}
-	return strings.ToLower(table)
-}
-
-// nearMissTable reports whether a table name is in the declared known-table
-// catalog; when it is not, and it is a singular/plural near-miss of a known
-// name, it returns the corrected name. The `user` vs `users` singular→plural
-// direction is what fires `unknown-table`. The catalog is empty when the caller
-// declared no known tables — then the rule cannot accuse (fail-open, matching
-// the TS schema reducer).
-func nearMissTable(knownTables map[string]bool, table string) (near string, known bool) {
-	if knownTables[table] {
-		return "", true
-	}
-	if knownTables[table+"s"] {
-		return table + "s", false
-	}
-	if knownTables[table+"es"] {
-		return table + "es", false
-	}
-	if strings.HasSuffix(table, "s") {
-		if base := strings.TrimSuffix(table, "s"); knownTables[base] {
-			return base, false
-		}
-	}
-	if strings.HasSuffix(table, "es") {
-		if base := strings.TrimSuffix(table, "es"); knownTables[base] {
-			return base, false
-		}
-	}
-	return "", false
-}
-
-// declaredTenantTables builds the tenant-scoped table set from the resolved
-// tiers the caller passed in `orgFilterTables`. Empty when the caller declared
-// no tenancy — the honest result is "no tenant tables", not a guessed list.
-func (a *Analyzer) declaredTenantTables() map[string]bool {
-	set := make(map[string]bool, len(a.options.OrgFilterTables))
-	for _, t := range a.options.OrgFilterTables {
-		set[strings.ToLower(t)] = true
-	}
-	return set
-}
-
-// declaredKnownTables builds the known-table catalog from the caller's
-// `knownTables`. An empty catalog means `unknown-table` cannot accuse.
-func (a *Analyzer) declaredKnownTables() map[string]bool {
-	set := make(map[string]bool, len(a.options.KnownTables))
-	for _, t := range a.options.KnownTables {
-		set[strings.ToLower(t)] = true
-	}
-	return set
-}
-
-// tenantPredicateRegex builds the tenant-predicate matcher from the configured
-// tenant columns (or the default set when none were supplied). Each column name
-// is regex-escaped and word-boundary-matched so a tenant column referenced
-// anywhere in the SQL counts as a tenant predicate.
-func (a *Analyzer) tenantPredicateRegex() *regexp.Regexp {
-	cols := a.options.OrgFilterColumns
-	if len(cols) == 0 {
-		cols = defaultOrgFilterColumns
-	}
-	alts := make([]string, 0, len(cols))
-	for _, c := range cols {
-		if c == "" {
-			continue
-		}
-		alts = append(alts, regexp.QuoteMeta(strings.ToLower(c)))
-	}
-	if len(alts) == 0 {
-		alts = append(alts, regexp.QuoteMeta(defaultOrgFilterColumns[0]))
-	}
-	return regexp.MustCompile(`(?i)\b(?:` + strings.Join(alts, "|") + `)\b`)
-}
-
-// isWriteVerb reports whether the verb mutates rows (INSERT/UPDATE/DELETE).
-func isWriteVerb(verb string) bool {
-	return verb == "INSERT" || verb == "UPDATE" || verb == "DELETE"
-}

package/dist/languages/go/analyzer-src/go.mod

@@ -1,3 +0,0 @@
-module code-auditor-go/analyzer
-
-go 1.19

package/dist/languages/go/analyzer-src/indexer.go

@@ -1,268 +0,0 @@
-package analyzer
-
-import (
-	"fmt"
-	"path/filepath"
-)
-
-// Indexer creates index entries for Go entities
-type Indexer struct {
-	parser *Parser
-}
-
-// NewIndexer creates a new indexer
-func NewIndexer(parser *Parser) *Indexer {
-	return &Indexer{
-		parser: parser,
-	}
-}
-
-// GenerateIndexEntries creates index entries for all parsed entities
-func (i *Indexer) GenerateIndexEntries() []IndexEntry {
-	// Non-nil empty slice so zero entries serialize to [] not null.
-	entries := make([]IndexEntry, 0)
-
-	// Index functions
-	functions := i.parser.ExtractFunctions()
-	for _, function := range functions {
-		entry := i.createFunctionIndexEntry(function)
-		entries = append(entries, entry)
-	}
-
-	// Index structs
-	structs := i.parser.ExtractStructs()
-	for _, structInfo := range structs {
-		entry := i.createStructIndexEntry(structInfo)
-		entries = append(entries, entry)
-	}
-
-	// Index interfaces
-	interfaces := i.parser.ExtractInterfaces()
-	for _, interfaceInfo := range interfaces {
-		entry := i.createInterfaceIndexEntry(interfaceInfo)
-		entries = append(entries, entry)
-	}
-
-	return entries
-}
-
-// createFunctionIndexEntry creates an index entry for a function
-func (i *Indexer) createFunctionIndexEntry(function Function) IndexEntry {
-	return IndexEntry{
-		ID:         i.generateID("function", function.File, function.Name, function.StartLine),
-		Name:       function.Name,
-		Type:       "function",
-		Language:   "go",
-		File:       function.File,
-		Signature:  function.Signature,
-		Parameters: function.Parameters,
-		Purpose:    function.Purpose,
-		Context:    i.generateContext(function.EntityInfo),
-		StartLine:  function.StartLine,
-		EndLine:    function.EndLine,
-		Metadata: map[string]interface{}{
-			"isMethod":     function.IsMethod,
-			"isExported":   function.IsExported,
-			"receiver":     function.Receiver,
-			"returnType":   function.ReturnType,
-			"complexity":   function.Complexity,
-			"package":      function.Package,
-			"dependencies": function.Dependencies,
-		},
-	}
-}
-
-// createStructIndexEntry creates an index entry for a struct
-func (i *Indexer) createStructIndexEntry(structInfo Struct) IndexEntry {
-	return IndexEntry{
-		ID:        i.generateID("struct", structInfo.File, structInfo.Name, structInfo.StartLine),
-		Name:      structInfo.Name,
-		Type:      "struct",
-		Language:  "go",
-		File:      structInfo.File,
-		Signature: structInfo.Signature,
-		Purpose:   i.generateStructPurpose(structInfo),
-		Context:   i.generateContext(structInfo.EntityInfo),
-		StartLine: structInfo.StartLine,
-		EndLine:   structInfo.EndLine,
-		Metadata: map[string]interface{}{
-			"isExported": structInfo.IsExported,
-			"fieldCount": len(structInfo.Fields),
-			"fields":     i.serializeFields(structInfo.Fields),
-			"methods":    structInfo.Methods,
-			"package":    structInfo.Package,
-		},
-	}
-}
-
-// createInterfaceIndexEntry creates an index entry for an interface
-func (i *Indexer) createInterfaceIndexEntry(interfaceInfo Interface) IndexEntry {
-	return IndexEntry{
-		ID:        i.generateID("interface", interfaceInfo.File, interfaceInfo.Name, interfaceInfo.StartLine),
-		Name:      interfaceInfo.Name,
-		Type:      "interface",
-		Language:  "go",
-		File:      interfaceInfo.File,
-		Signature: interfaceInfo.Signature,
-		Purpose:   i.generateInterfacePurpose(interfaceInfo),
-		Context:   i.generateContext(interfaceInfo.EntityInfo),
-		StartLine: interfaceInfo.StartLine,
-		EndLine:   interfaceInfo.EndLine,
-		Metadata: map[string]interface{}{
-			"isExported":   interfaceInfo.IsExported,
-			"methodCount":  len(interfaceInfo.Methods),
-			"methods":      i.serializeMethods(interfaceInfo.Methods),
-			"package":      interfaceInfo.Package,
-		},
-	}
-}
-
-// generateID creates a unique ID for an entity
-func (i *Indexer) generateID(entityType, file, name string, line int) string {
-	return fmt.Sprintf("go:%s:%s:%s:%d", entityType, filepath.Base(file), name, line)
-}
-
-// generateContext creates context information for an entity
-func (i *Indexer) generateContext(entity EntityInfo) string {
-	return fmt.Sprintf("Go %s in package %s at %s:%d", 
-		entity.Type, entity.Package, filepath.Base(entity.File), entity.StartLine)
-}
-
-// generateStructPurpose creates a purpose description for a struct
-func (i *Indexer) generateStructPurpose(structInfo Struct) string {
-	if structInfo.Purpose != "" {
-		return structInfo.Purpose
-	}
-
-	fieldCount := len(structInfo.Fields)
-	if fieldCount == 0 {
-		return fmt.Sprintf("Empty struct %s", structInfo.Name)
-	}
-
-	return fmt.Sprintf("Data structure with %d fields representing %s", 
-		fieldCount, i.inferStructPurpose(structInfo))
-}
-
-// generateInterfacePurpose creates a purpose description for an interface
-func (i *Indexer) generateInterfacePurpose(interfaceInfo Interface) string {
-	if interfaceInfo.Purpose != "" {
-		return interfaceInfo.Purpose
-	}
-
-	methodCount := len(interfaceInfo.Methods)
-	if methodCount == 0 {
-		return fmt.Sprintf("Empty interface %s", interfaceInfo.Name)
-	}
-
-	return fmt.Sprintf("Interface defining %d methods for %s behavior", 
-		methodCount, i.inferInterfacePurpose(interfaceInfo))
-}
-
-// inferStructPurpose tries to infer the purpose of a struct from its name and fields
-func (i *Indexer) inferStructPurpose(structInfo Struct) string {
-	name := structInfo.Name
-	
-	// Common patterns in Go struct names
-	if containsAny(name, []string{"Config", "Configuration"}) {
-		return "configuration data"
-	}
-	if containsAny(name, []string{"Request", "Req"}) {
-		return "request data"
-	}
-	if containsAny(name, []string{"Response", "Resp"}) {
-		return "response data"
-	}
-	if containsAny(name, []string{"Handler", "Controller"}) {
-		return "request handling"
-	}
-	if containsAny(name, []string{"Service", "Manager"}) {
-		return "business logic"
-	}
-	if containsAny(name, []string{"Repository", "Repo", "Store"}) {
-		return "data access"
-	}
-	if containsAny(name, []string{"Model", "Entity"}) {
-		return "data model"
-	}
-	if containsAny(name, []string{"Client", "Adapter"}) {
-		return "external integration"
-	}
-
-	return "entity data"
-}
-
-// inferInterfacePurpose tries to infer the purpose of an interface from its name and methods
-func (i *Indexer) inferInterfacePurpose(interfaceInfo Interface) string {
-	name := interfaceInfo.Name
-	
-	// Common patterns in Go interface names
-	if containsAny(name, []string{"Reader", "Writer", "ReadWriter"}) {
-		return "I/O operations"
-	}
-	if containsAny(name, []string{"Handler", "Processor"}) {
-		return "request processing"
-	}
-	if containsAny(name, []string{"Repository", "Store"}) {
-		return "data storage"
-	}
-	if containsAny(name, []string{"Service", "Provider"}) {
-		return "service operations"
-	}
-	if containsAny(name, []string{"Client", "Adapter"}) {
-		return "external communication"
-	}
-	if containsAny(name, []string{"Validator", "Checker"}) {
-		return "validation logic"
-	}
-	if containsAny(name, []string{"Builder", "Factory"}) {
-		return "object creation"
-	}
-
-	return "behavioral contract"
-}
-
-// serializeFields converts struct fields to a serializable format
-func (i *Indexer) serializeFields(fields []Field) []map[string]interface{} {
-	var serialized []map[string]interface{}
-	
-	for _, field := range fields {
-		serialized = append(serialized, map[string]interface{}{
-			"name":       field.Name,
-			"type":       field.Type,
-			"tag":        field.Tag,
-			"isExported": field.IsExported,
-		})
-	}
-	
-	return serialized
-}
-
-// serializeMethods converts interface methods to a serializable format
-func (i *Indexer) serializeMethods(methods []Method) []map[string]interface{} {
-	var serialized []map[string]interface{}
-	
-	for _, method := range methods {
-		serialized = append(serialized, map[string]interface{}{
-			"name":       method.Name,
-			"signature":  method.Signature,
-			"parameters": method.Parameters,
-			"returnType": method.ReturnType,
-		})
-	}
-	
-	return serialized
-}
-
-// containsAny checks if a string contains any of the given substrings
-func containsAny(str string, substrings []string) bool {
-	for _, substring := range substrings {
-		if len(str) >= len(substring) {
-			for i := 0; i <= len(str)-len(substring); i++ {
-				if str[i:i+len(substring)] == substring {
-					return true
-				}
-			}
-		}
-	}
-	return false
-}