codemaxxing 0.1.0

package/dist/utils/repomap.js

@@ -0,0 +1,195 @@
+import { readFileSync, readdirSync, statSync } from "fs";
+import { join, extname, relative } from "path";
+const IGNORE_DIRS = new Set([
+    "node_modules", ".git", "dist", ".next", "__pycache__", ".pytest_cache",
+    "target", "build", "out", ".cache", ".parcel-cache", ".nuxt", ".svelte-kit",
+    "vendor", "venv", ".venv", "env", ".env", "coverage", ".nyc_output",
+]);
+const IGNORE_FILES = new Set([
+    ".DS_Store", "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
+]);
+const MAX_FILE_SIZE = 100 * 1024;
+const MAX_MAP_SIZE = 15 * 1024;
+const LANGS = {
+    javascript: {
+        patterns: [
+            { kind: "fn", regex: /^(?:export\s+)?(?:export\s+default\s+)?(?:async\s+)?function\s+(\w+)\s*\(/, format: (m) => `function ${m[1]}(...)` },
+            { kind: "arrow", regex: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/, format: (m) => `const ${m[1]} = (...)` },
+            { kind: "cls", regex: /^(?:export\s+)?(?:export\s+default\s+)?class\s+(\w+)/, format: (m) => `class ${m[1]}` },
+        ],
+    },
+    typescript: {
+        patterns: [
+            { kind: "fn", regex: /^(?:export\s+)?(?:export\s+default\s+)?(?:async\s+)?function\s+(\w+)/, format: (m) => `function ${m[1]}(...)` },
+            { kind: "arrow", regex: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/, format: (m) => `const ${m[1]} = (...)` },
+            { kind: "cls", regex: /^(?:export\s+)?(?:export\s+default\s+)?class\s+(\w+)/, format: (m) => `class ${m[1]}` },
+            { kind: "iface", regex: /^(?:export\s+)?interface\s+(\w+)/, format: (m) => `interface ${m[1]}` },
+            { kind: "type", regex: /^(?:export\s+)?type\s+(\w+)\s*[=<]/, format: (m) => `type ${m[1]}` },
+            { kind: "enum", regex: /^(?:export\s+)?enum\s+(\w+)/, format: (m) => `enum ${m[1]}` },
+        ],
+    },
+    python: {
+        patterns: [
+            { kind: "fn", regex: /^def\s+(\w+)\s*\(/, format: (m) => `def ${m[1]}(...)` },
+            { kind: "method", regex: /^\s{2,}def\s+(\w+)\s*\(/, format: (m) => `  def ${m[1]}(...)` },
+            { kind: "cls", regex: /^class\s+(\w+)/, format: (m) => `class ${m[1]}` },
+        ],
+    },
+    go: {
+        patterns: [
+            { kind: "fn", regex: /^func\s+(\w+)\s*\(/, format: (m) => `func ${m[1]}(...)` },
+            { kind: "method", regex: /^func\s+\((\w+)\s+\*?(\w+)\)\s+(\w+)\s*\(/, format: (m) => `func (${m[2]}) ${m[3]}(...)` },
+            { kind: "struct", regex: /^type\s+(\w+)\s+struct/, format: (m) => `type ${m[1]} struct` },
+            { kind: "iface", regex: /^type\s+(\w+)\s+interface/, format: (m) => `type ${m[1]} interface` },
+        ],
+    },
+    rust: {
+        patterns: [
+            { kind: "fn", regex: /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/, format: (m) => `fn ${m[1]}(...)` },
+            { kind: "struct", regex: /^(?:pub\s+)?struct\s+(\w+)/, format: (m) => `struct ${m[1]}` },
+            { kind: "enum", regex: /^(?:pub\s+)?enum\s+(\w+)/, format: (m) => `enum ${m[1]}` },
+            { kind: "trait", regex: /^(?:pub\s+)?trait\s+(\w+)/, format: (m) => `trait ${m[1]}` },
+            { kind: "impl", regex: /^impl(?:<[^>]*>)?\s+(?:(\w+)\s+for\s+)?(\w+)/, format: (m) => m[1] ? `impl ${m[1]} for ${m[2]}` : `impl ${m[2]}` },
+            { kind: "mod", regex: /^(?:pub\s+)?mod\s+(\w+)/, format: (m) => `mod ${m[1]}` },
+        ],
+    },
+};
+/**
+ * Get language from extension
+ */
+function getLang(ext) {
+    const map = {
+        ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript",
+        ".ts": "typescript", ".tsx": "typescript",
+        ".py": "python",
+        ".go": "go",
+        ".rs": "rust",
+    };
+    return map[ext.toLowerCase()] || null;
+}
+/**
+ * Extract signatures from file content
+ */
+function extractSignatures(content, lang) {
+    const sigs = [];
+    const langDef = LANGS[lang];
+    if (!langDef)
+        return sigs;
+    const lines = content.split("\n");
+    const seen = new Set();
+    for (const line of lines) {
+        for (const pattern of langDef.patterns) {
+            const match = line.match(pattern.regex);
+            if (match) {
+                const sig = pattern.format(match);
+                if (!seen.has(sig)) {
+                    seen.add(sig);
+                    sigs.push(sig);
+                }
+                break; // Only match one pattern per line
+            }
+        }
+    }
+    return sigs;
+}
+/**
+ * Scan directory for supported files
+ */
+function getFiles(cwd) {
+    const files = [];
+    function walk(dir, depth) {
+        if (depth > 5)
+            return;
+        try {
+            for (const entry of readdirSync(dir)) {
+                if (IGNORE_FILES.has(entry) || entry.startsWith("."))
+                    continue;
+                if (IGNORE_DIRS.has(entry))
+                    continue;
+                const full = join(dir, entry);
+                const stat = statSync(full);
+                if (stat.isDirectory()) {
+                    walk(full, depth + 1);
+                }
+                else if (stat.isFile() && stat.size < MAX_FILE_SIZE) {
+                    if (getLang(extname(entry)))
+                        files.push(full);
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    walk(cwd, 0);
+    return files;
+}
+// ── Cache ──
+let cachedMap = "";
+let cachedCwd = "";
+let cachedTime = 0;
+const CACHE_TTL = 60_000;
+/**
+ * Build the repo map — cached for 1 min
+ */
+export async function buildRepoMap(cwd) {
+    const now = Date.now();
+    if (cachedMap && cachedCwd === cwd && now - cachedTime < CACHE_TTL) {
+        return cachedMap;
+    }
+    const files = getFiles(cwd);
+    const lines = [];
+    for (const file of files) {
+        const ext = extname(file);
+        const lang = getLang(ext);
+        if (!lang)
+            continue;
+        try {
+            const content = readFileSync(file, "utf-8");
+            const sigs = extractSignatures(content, lang);
+            if (sigs.length > 0) {
+                const relPath = relative(cwd, file);
+                lines.push(`${relPath}:`);
+                for (const sig of sigs) {
+                    lines.push(`  ${sig}`);
+                }
+                lines.push("");
+                // Size guard
+                if (lines.join("\n").length > MAX_MAP_SIZE) {
+                    lines.push(`... (truncated)`);
+                    break;
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    const map = lines.length > 0 ? lines.join("\n") : "(no signatures found)";
+    cachedMap = map;
+    cachedCwd = cwd;
+    cachedTime = now;
+    return map;
+}
+/**
+ * Get cached map without rebuilding
+ */
+export function getCachedMap() {
+    return cachedMap;
+}
+/**
+ * Clear the cache
+ */
+export function clearMapCache() {
+    cachedMap = "";
+    cachedCwd = "";
+    cachedTime = 0;
+}
+/**
+ * Check if file is supported
+ */
+export function isSupportedFile(filePath) {
+    return !!getLang(extname(filePath).toLowerCase());
+}
+export function getSupportedExtensions() {
+    return [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rs"];
+}
+export function getLanguageForExt(ext) {
+    return getLang(ext);
+}

package/dist/utils/sessions.d.ts

@@ -0,0 +1,51 @@
+import type { ChatCompletionMessageParam } from "openai/resources/chat/completions";
+/**
+ * Create a new session
+ */
+export declare function createSession(cwd: string, model: string): string;
+/**
+ * Save a message to a session
+ */
+export declare function saveMessage(sessionId: string, message: ChatCompletionMessageParam): void;
+/**
+ * Update token estimate for a session
+ */
+export declare function updateTokenEstimate(sessionId: string, tokens: number): void;
+/**
+ * List recent sessions
+ */
+export interface SessionInfo {
+    id: string;
+    cwd: string;
+    model: string;
+    created_at: string;
+    updated_at: string;
+    message_count: number;
+    token_estimate: number;
+    summary: string | null;
+}
+export declare function listSessions(limit?: number): SessionInfo[];
+/**
+ * Load all messages for a session
+ */
+export declare function loadMessages(sessionId: string): ChatCompletionMessageParam[];
+/**
+ * Get a specific session
+ */
+export declare function getSession(sessionId: string): SessionInfo | null;
+/**
+ * Delete a session and its messages
+ */
+export declare function deleteSession(sessionId: string): boolean;
+/**
+ * Update session summary (for context compression)
+ */
+export declare function updateSummary(sessionId: string, summary: string): void;
+/**
+ * Get the most recent session for a given cwd
+ */
+export declare function getLastSession(cwd: string): SessionInfo | null;
+/**
+ * Close the database connection
+ */
+export declare function closeDb(): void;

package/dist/utils/sessions.js

@@ -0,0 +1,174 @@
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CONFIG_DIR = join(homedir(), ".codemaxxing");
+const DB_PATH = join(CONFIG_DIR, "sessions.db");
+let db = null;
+/**
+ * Initialize the database and create tables if needed
+ */
+function getDb() {
+    if (db)
+        return db;
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    db = new Database(DB_PATH);
+    // Enable WAL mode for better concurrent performance
+    db.pragma("journal_mode = WAL");
+    // Create tables
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      cwd TEXT NOT NULL,
+      model TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      message_count INTEGER NOT NULL DEFAULT 0,
+      token_estimate INTEGER NOT NULL DEFAULT 0,
+      summary TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT,
+      tool_calls TEXT,
+      tool_call_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+  `);
+    return db;
+}
+/**
+ * Generate a short session ID (8 chars)
+ */
+function generateId() {
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    let id = "";
+    for (let i = 0; i < 8; i++) {
+        id += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return id;
+}
+/**
+ * Create a new session
+ */
+export function createSession(cwd, model) {
+    const db = getDb();
+    const id = generateId();
+    db.prepare(`
+    INSERT INTO sessions (id, cwd, model) VALUES (?, ?, ?)
+  `).run(id, cwd, model);
+    return id;
+}
+/**
+ * Save a message to a session
+ */
+export function saveMessage(sessionId, message) {
+    const db = getDb();
+    const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+    const toolCalls = "tool_calls" in message && message.tool_calls
+        ? JSON.stringify(message.tool_calls)
+        : null;
+    const toolCallId = "tool_call_id" in message ? message.tool_call_id : null;
+    db.prepare(`
+    INSERT INTO messages (session_id, role, content, tool_calls, tool_call_id)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(sessionId, message.role, content, toolCalls, toolCallId);
+    // Update session metadata
+    const stats = db.prepare(`
+    SELECT COUNT(*) as count FROM messages WHERE session_id = ?
+  `).get(sessionId);
+    db.prepare(`
+    UPDATE sessions SET updated_at = datetime('now'), message_count = ? WHERE id = ?
+  `).run(stats.count, sessionId);
+}
+/**
+ * Update token estimate for a session
+ */
+export function updateTokenEstimate(sessionId, tokens) {
+    const db = getDb();
+    db.prepare(`
+    UPDATE sessions SET token_estimate = ? WHERE id = ?
+  `).run(tokens, sessionId);
+}
+export function listSessions(limit = 10) {
+    const db = getDb();
+    return db.prepare(`
+    SELECT * FROM sessions ORDER BY updated_at DESC LIMIT ?
+  `).all(limit);
+}
+/**
+ * Load all messages for a session
+ */
+export function loadMessages(sessionId) {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT role, content, tool_calls, tool_call_id FROM messages
+    WHERE session_id = ? ORDER BY id ASC
+  `).all(sessionId);
+    return rows.map((row) => {
+        const msg = { role: row.role, content: row.content };
+        if (row.tool_calls) {
+            try {
+                msg.tool_calls = JSON.parse(row.tool_calls);
+            }
+            catch { /* ignore */ }
+        }
+        if (row.tool_call_id) {
+            msg.tool_call_id = row.tool_call_id;
+        }
+        return msg;
+    });
+}
+/**
+ * Get a specific session
+ */
+export function getSession(sessionId) {
+    const db = getDb();
+    return db.prepare(`
+    SELECT * FROM sessions WHERE id = ?
+  `).get(sessionId) || null;
+}
+/**
+ * Delete a session and its messages
+ */
+export function deleteSession(sessionId) {
+    const db = getDb();
+    db.prepare(`DELETE FROM messages WHERE session_id = ?`).run(sessionId);
+    const result = db.prepare(`DELETE FROM sessions WHERE id = ?`).run(sessionId);
+    return result.changes > 0;
+}
+/**
+ * Update session summary (for context compression)
+ */
+export function updateSummary(sessionId, summary) {
+    const db = getDb();
+    db.prepare(`
+    UPDATE sessions SET summary = ? WHERE id = ?
+  `).run(summary, sessionId);
+}
+/**
+ * Get the most recent session for a given cwd
+ */
+export function getLastSession(cwd) {
+    const db = getDb();
+    return db.prepare(`
+    SELECT * FROM sessions WHERE cwd = ? ORDER BY updated_at DESC LIMIT 1
+  `).get(cwd) || null;
+}
+/**
+ * Close the database connection
+ */
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist/utils/treesitter.d.ts

@@ -0,0 +1,20 @@
+export interface Signature {
+    kind: "function" | "class" | "method" | "interface" | "type" | "enum" | "struct" | "trait" | "impl" | "variable" | "const" | "module" | "package" | "export";
+    name: string;
+    detail: string;
+    startLine: number;
+    endLine: number;
+    children?: Signature[];
+}
+/**
+ * Get the language name for a file extension
+ */
+export declare function getLanguageForExt(ext: string): string | null;
+/**
+ * Get all supported extensions
+ */
+export declare function getSupportedExtensions(): string[];
+/**
+ * Parse a file and extract signatures using tree-sitter queries
+ */
+export declare function extractSignatures(source: string, langName: string): Promise<Signature[]>;