clast-ai 0.1.0

package/src/server/tools/clast-get-context.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ClastDatabase } from '../../db/index.js';
+
+export function registerGetContextTool(server: McpServer, db: ClastDatabase): void {
+  server.tool(
+    'clast_get_context',
+    'Get full context for a symbol: its definition, comments/documentation, callers, callees, and parent class (if method). This is the primary tool for understanding a symbol before editing — use instead of reading the whole file.',
+    {
+      name: z.string().describe('Symbol name to look up'),
+      includeBody: z.boolean().default(false).describe('Include the full function/class body text'),
+    },
+    async ({ name, includeBody }) => {
+      const ctx = db.queries.getNodeWithContext(name);
+
+      if (ctx.nodes.length === 0) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({ error: `No symbol found with name "${name}"` }),
+          }],
+        };
+      }
+
+      const result = ctx.nodes.map(node => {
+        const nodeComments = ctx.comments.filter(c => c.node_id === node.id);
+        const entry: Record<string, unknown> = {
+          name: node.name,
+          type: node.type,
+          filePath: node.file_path,
+          location: `${node.file_path}:${node.start_line}-${node.end_line}`,
+          signature: node.signature,
+          language: node.language,
+        };
+
+        if (includeBody) {
+          entry.body = node.body_text;
+        }
+
+        // Comments: prioritize original, also show generated
+        const originalComment = nodeComments.find(c => c.source === 'original');
+        const generatedComment = nodeComments.find(c => c.source === 'generated');
+
+        if (originalComment) {
+          entry.comment = originalComment.text;
+          entry.commentSource = 'original';
+        }
+        if (generatedComment) {
+          entry.generatedDescription = generatedComment.text;
+        }
+
+        // Parent (for methods inside classes)
+        if (node.parent_id) {
+          const parent = db.queries.getNodeById(node.parent_id);
+          if (parent) {
+            entry.parentClass = {
+              name: parent.name,
+              type: parent.type,
+              filePath: parent.file_path,
+              startLine: parent.start_line,
+            };
+          }
+        }
+
+        return entry;
+      });
+
+      // Callers and callees (deduplicated across all matching nodes)
+      const callers = ctx.callers.map(n => ({
+        name: n.name,
+        type: n.type,
+        filePath: n.file_path,
+        startLine: n.start_line,
+        signature: n.signature,
+      }));
+
+      const callees = ctx.callees.map(n => ({
+        name: n.name,
+        type: n.type,
+        filePath: n.file_path,
+        startLine: n.start_line,
+        signature: n.signature,
+      }));
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: JSON.stringify({
+            definitions: result,
+            callers,
+            callees,
+          }, null, 2),
+        }],
+      };
+    }
+  );
+}

package/src/server/tools/clast-reindex.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { join } from 'node:path';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ClastDatabase } from '../../db/index.js';
+import type { ParserManager } from '../../parser/index.js';
+
+export function registerReindexTool(
+  server: McpServer,
+  db: ClastDatabase,
+  parser: ParserManager,
+  projectRoot: string
+): void {
+  server.tool(
+    'clast_reindex',
+    'Force re-index a specific file or the entire repository. Use when the index seems stale or after large changes.',
+    {
+      filePath: z.string().optional().describe('Specific file to reindex (relative path). Omit to reindex the entire repo.'),
+    },
+    async ({ filePath }) => {
+      if (filePath) {
+        const absPath = join(projectRoot, filePath);
+        const parsed = await parser.incrementalUpdate(absPath, projectRoot, db);
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              file: filePath,
+              reindexed: parsed,
+              message: parsed ? 'File reindexed successfully' : 'File unchanged or unsupported',
+            }),
+          }],
+        };
+      }
+
+      const result = await parser.fullIndex(projectRoot, db);
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: JSON.stringify({
+            filesProcessed: result.filesProcessed,
+            nodesFound: result.nodesFound,
+            edgesResolved: result.edgesResolved,
+            durationMs: result.durationMs,
+            message: `Full reindex completed in ${result.durationMs}ms`,
+          }),
+        }],
+      };
+    }
+  );
+}

package/src/server/tools/clast-search.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ClastDatabase } from '../../db/index.js';
+
+export function registerSearchTool(server: McpServer, db: ClastDatabase): void {
+  server.tool(
+    'clast_search',
+    'Search AST nodes (functions, classes, methods, etc.) by name pattern and optional type filter. Returns matching symbols with file locations and signatures.',
+    {
+      query: z.string().describe('Search pattern (matches against symbol names, supports partial matches)'),
+      type: z.enum([
+        'function', 'method', 'class', 'interface', 'enum',
+        'import', 'export', 'variable', 'type_alias', 'struct', 'trait', 'module',
+      ]).optional().describe('Filter by symbol type'),
+      limit: z.number().int().min(1).max(100).default(20).describe('Maximum results to return'),
+    },
+    async ({ query, type, limit }) => {
+      const results = db.queries.searchNodes(query, type, limit);
+
+      const formatted = results.map(n => ({
+        name: n.name,
+        type: n.type,
+        filePath: n.file_path,
+        startLine: n.start_line,
+        endLine: n.end_line,
+        signature: n.signature,
+        language: n.language,
+      }));
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: JSON.stringify(formatted, null, 2),
+        }],
+      };
+    }
+  );
+}

package/src/server/tools/clast-status.ts

@@ -0,0 +1,37 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ClastDatabase } from '../../db/index.js';
+import type { FileWatcher } from '../../watcher/index.js';
+
+export function registerStatusTool(
+  server: McpServer,
+  db: ClastDatabase,
+  watcher: FileWatcher
+): void {
+  server.tool(
+    'clast_status',
+    'Show the current indexing status: files indexed, total symbols, total call edges, watcher state, and pending updates.',
+    {},
+    async () => {
+      const status = db.queries.getStatus();
+
+      const result = {
+        filesIndexed: status.files_indexed,
+        totalNodes: status.total_nodes,
+        totalEdges: status.total_edges,
+        totalComments: status.total_comments,
+        lastIndexed: status.last_indexed
+          ? new Date(status.last_indexed).toISOString()
+          : null,
+        watcherActive: watcher.isActive,
+        pendingFiles: watcher.pendingCount,
+      };
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: JSON.stringify(result, null, 2),
+        }],
+      };
+    }
+  );
+}

package/src/types.ts

@@ -0,0 +1,69 @@
+export type AstNodeType =
+  | 'function'
+  | 'method'
+  | 'class'
+  | 'interface'
+  | 'enum'
+  | 'import'
+  | 'export'
+  | 'variable'
+  | 'type_alias'
+  | 'struct'
+  | 'trait'
+  | 'module';
+
+export interface AstNode {
+  id?: number;
+  filePath: string;
+  name: string;
+  type: AstNodeType;
+  signature: string;
+  startLine: number;
+  endLine: number;
+  startCol: number;
+  endCol: number;
+  parentId: number | null;
+  language: string;
+  bodyText: string;
+}
+
+export interface CallEdge {
+  id?: number;
+  callerId: number;
+  calleeId: number | null;
+  calleeName: string;
+  filePath: string;
+  line: number;
+}
+
+export interface FileInfo {
+  filePath: string;
+  hash: string;
+  language: string;
+  lastIndexed: number;
+  nodeCount: number;
+}
+
+export interface CommentInfo {
+  id?: number;
+  nodeId: number;
+  text: string;
+  source: 'original' | 'generated';
+  generatedAt: number | null;
+}
+
+export interface ParseResult {
+  nodes: AstNode[];
+  edges: CallEdge[];
+  comments: CommentInfo[];
+}
+
+export interface IndexStatus {
+  filesIndexed: number;
+  totalNodes: number;
+  totalEdges: number;
+  totalComments: number;
+  lastIndexed: number | null;
+  watcherActive: boolean;
+  pendingFiles: number;
+}

package/src/watcher/gitignore.ts

@@ -0,0 +1,42 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Parse .gitignore files into glob patterns suitable for chokidar's `ignored` option.
+ */
+export function loadGitignorePatterns(projectRoot: string): string[] {
+  const patterns: string[] = [];
+  const gitignorePath = join(projectRoot, '.gitignore');
+
+  if (!existsSync(gitignorePath)) return patterns;
+
+  try {
+    const content = readFileSync(gitignorePath, 'utf-8');
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      // Skip comments and empty lines
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      // Negation patterns are not supported by chokidar's simple ignored
+      if (trimmed.startsWith('!')) continue;
+
+      patterns.push(trimmed);
+    }
+  } catch {
+    // Silently ignore read errors
+  }
+
+  return patterns;
+}
+
+/**
+ * Build the full ignored patterns list combining .gitignore and config.
+ */
+export function buildIgnorePatterns(
+  projectRoot: string,
+  configIgnored: string[]
+): string[] {
+  const gitignorePatterns = loadGitignorePatterns(projectRoot);
+  // Deduplicate
+  const all = new Set([...configIgnored, ...gitignorePatterns]);
+  return Array.from(all);
+}

package/src/watcher/index.ts

@@ -0,0 +1,131 @@
+import { watch, type FSWatcher } from 'chokidar';
+import { extname } from 'node:path';
+import { EventEmitter } from 'node:events';
+import { getSupportedExtensions } from '../parser/languages.js';
+import { buildIgnorePatterns } from './gitignore.js';
+import type { ParserManager } from '../parser/index.js';
+import type { ClastDatabase } from '../db/index.js';
+import type { ClastConfig } from '../config/index.js';
+
+export class FileWatcher extends EventEmitter {
+  private watcher: FSWatcher | null = null;
+  private projectRoot: string;
+  private config: ClastConfig;
+  private db: ClastDatabase;
+  private parser: ParserManager;
+  private debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  private _pendingCount = 0;
+  private supportedExts: Set<string>;
+
+  constructor(
+    projectRoot: string,
+    config: ClastConfig,
+    db: ClastDatabase,
+    parser: ParserManager
+  ) {
+    super();
+    this.projectRoot = projectRoot;
+    this.config = config;
+    this.db = db;
+    this.parser = parser;
+    this.supportedExts = new Set(getSupportedExtensions(config.languages));
+  }
+
+  get isActive(): boolean {
+    return this.watcher !== null;
+  }
+
+  get pendingCount(): number {
+    return this._pendingCount;
+  }
+
+  start(): void {
+    if (this.watcher) return;
+    if (!this.config.watch.enabled) return;
+
+    const ignoredPatterns = buildIgnorePatterns(this.projectRoot, this.config.ignoredPaths);
+
+    this.watcher = watch(this.projectRoot, {
+      ignored: [
+        /(^|[/\\])\./,
+        ...ignoredPatterns.map(p => {
+          if (!p.includes('*') && !p.includes('/')) {
+            return `**/${p}/**`;
+          }
+          return p;
+        }),
+      ],
+      persistent: true,
+      ignoreInitial: true,
+    });
+
+    this.watcher.on('add', path => this.handleFileChange(path));
+    this.watcher.on('change', path => this.handleFileChange(path));
+    this.watcher.on('unlink', path => this.handleFileDelete(path));
+    this.watcher.on('error', err => {
+      console.error('[clast] Watcher error:', err);
+    });
+  }
+
+  stop(): void {
+    if (!this.watcher) return;
+
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+
+    this.watcher.close();
+    this.watcher = null;
+  }
+
+  private handleFileChange(filePath: string): void {
+    const ext = extname(filePath);
+    if (!this.supportedExts.has(ext)) return;
+
+    const existing = this.debounceTimers.get(filePath);
+    if (existing) clearTimeout(existing);
+
+    this._pendingCount++;
+    this.debounceTimers.set(
+      filePath,
+      setTimeout(() => {
+        this.debounceTimers.delete(filePath);
+        this._pendingCount--;
+        this.processFile(filePath);
+      }, this.config.watch.debounceMs)
+    );
+  }
+
+  private handleFileDelete(filePath: string): void {
+    const ext = extname(filePath);
+    if (!this.supportedExts.has(ext)) return;
+
+    const existing = this.debounceTimers.get(filePath);
+    if (existing) {
+      clearTimeout(existing);
+      this.debounceTimers.delete(filePath);
+      this._pendingCount--;
+    }
+
+    try {
+      this.parser.removeFile(filePath, this.projectRoot, this.db);
+      this.emit('deleted', { filePath });
+    } catch (err) {
+      this.emit('error', { filePath, error: err as Error });
+    }
+  }
+
+  private async processFile(filePath: string): Promise<void> {
+    try {
+      const parsed = await this.parser.incrementalUpdate(filePath, this.projectRoot, this.db);
+      if (parsed) {
+        const relPath = filePath.replace(/\\/g, '/');
+        const nodes = this.db.queries.getNodesByFile(relPath);
+        this.emit('indexed', { filePath, nodesFound: nodes.length });
+      }
+    } catch (err) {
+      this.emit('error', { filePath, error: err as Error });
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "test"]
+}