Evan Reichard
dfd61f899a
- Only register tool if `codexis` binary is in PATH - Run incremental index via `pi.exec` on each tool call to keep DB fresh - Remove `findDatabase` helper; derive DB path from git root directly - Replace `defineTool` with inline `pi.registerTool` call - Update imports (`@sinclair/typebox`, lazy `execSync`) - Fix output flag help text in main.go
128 lines
3.4 KiB
Go
128 lines
3.4 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
_ "github.com/mattn/go-sqlite3"
|
|
|
|
"codexis/db"
|
|
"codexis/indexer"
|
|
)
|
|
|
|
const dbDir = ".codexis"
|
|
const dbFileName = "index.db"
|
|
|
|
func main() {
|
|
force := flag.Bool("force", false, "Force full re-index (ignore file hashes)")
|
|
output := flag.String("o", "", "Output database path (default: <root>/.codexis/index.db)")
|
|
flag.Parse()
|
|
|
|
root := "."
|
|
if flag.NArg() > 0 {
|
|
root = flag.Arg(0)
|
|
}
|
|
|
|
absRoot, err := filepath.Abs(root)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
dbDirPath := filepath.Join(absRoot, dbDir)
|
|
if err := os.MkdirAll(dbDirPath, 0755); err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
dbPath := filepath.Join(dbDirPath, dbFileName)
|
|
if *output != "" {
|
|
dbPath = *output
|
|
}
|
|
|
|
if err := run(absRoot, dbPath, *force); err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func run(root, dbPath string, force bool) error {
|
|
ctx := context.Background()
|
|
|
|
sqlDB, err := sql.Open("sqlite3", dbPath+"?_journal_mode=WAL&_foreign_keys=on")
|
|
if err != nil {
|
|
return fmt.Errorf("opening database: %w", err)
|
|
}
|
|
defer sqlDB.Close()
|
|
|
|
// Create schema
|
|
if err := createSchema(ctx, sqlDB); err != nil {
|
|
return fmt.Errorf("creating schema: %w", err)
|
|
}
|
|
|
|
queries := db.New(sqlDB)
|
|
idx := indexer.New(queries, root, force)
|
|
|
|
start := time.Now()
|
|
fmt.Fprintf(os.Stderr, "Indexing %s...\n", root)
|
|
|
|
stats, err := idx.Index(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("indexing: %w", err)
|
|
}
|
|
|
|
elapsed := time.Since(start)
|
|
fmt.Fprintf(os.Stderr, "Done in %s\n", elapsed.Round(time.Millisecond))
|
|
fmt.Fprintf(os.Stderr, " Files: %d total, %d indexed, %d unchanged\n",
|
|
stats.FilesTotal, stats.FilesIndexed, stats.FilesSkipped)
|
|
fmt.Fprintf(os.Stderr, " Symbols: %d\n", stats.SymbolsTotal)
|
|
fmt.Fprintf(os.Stderr, " Output: %s\n", dbPath)
|
|
|
|
return nil
|
|
}
|
|
|
|
func createSchema(ctx context.Context, sqlDB *sql.DB) error {
|
|
schema := `
|
|
CREATE TABLE IF NOT EXISTS files (
|
|
id INTEGER PRIMARY KEY,
|
|
path TEXT NOT NULL UNIQUE,
|
|
language TEXT NOT NULL,
|
|
package TEXT,
|
|
hash TEXT NOT NULL,
|
|
indexed_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS symbols (
|
|
id INTEGER PRIMARY KEY,
|
|
file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
|
|
name TEXT NOT NULL,
|
|
kind TEXT NOT NULL CHECK(kind IN (
|
|
'function', 'method', 'class', 'type',
|
|
'interface', 'constant', 'variable', 'constructor'
|
|
)),
|
|
line INTEGER NOT NULL,
|
|
line_end INTEGER,
|
|
col INTEGER,
|
|
col_end INTEGER,
|
|
exported BOOLEAN,
|
|
parent_id INTEGER REFERENCES symbols(id),
|
|
UNIQUE(file_id, name, kind, line)
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
|
|
CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind);
|
|
CREATE INDEX IF NOT EXISTS idx_symbols_file_line ON symbols(file_id, line);
|
|
CREATE INDEX IF NOT EXISTS idx_symbols_parent ON symbols(parent_id);
|
|
CREATE INDEX IF NOT EXISTS idx_symbols_exported ON symbols(exported, kind);
|
|
CREATE INDEX IF NOT EXISTS idx_files_path ON files(path);
|
|
CREATE INDEX IF NOT EXISTS idx_files_language ON files(language);
|
|
CREATE INDEX IF NOT EXISTS idx_files_package ON files(package);
|
|
`
|
|
_, err := sqlDB.ExecContext(ctx, schema)
|
|
return err
|
|
}
|