codemaxxing 0.1.0

package/src/utils/repomap.ts

@@ -0,0 +1,220 @@
+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;
+
+// ── Per-line regex patterns (no /g flag!) ──
+
+interface LangPatterns {
+  patterns: Array<{ kind: string; regex: RegExp; format: (m: RegExpMatchArray) => string }>;
+}
+
+const LANGS: Record<string, LangPatterns> = {
+  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: string): string | null {
+  const map: Record<string, string> = {
+    ".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: string, lang: string): string[] {
+  const sigs: string[] = [];
+  const langDef = LANGS[lang];
+  if (!langDef) return sigs;
+
+  const lines = content.split("\n");
+  const seen = new Set<string>();
+
+  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: string): string[] {
+  const files: string[] = [];
+
+  function walk(dir: string, depth: number) {
+    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: string): Promise<string> {
+  const now = Date.now();
+  if (cachedMap && cachedCwd === cwd && now - cachedTime < CACHE_TTL) {
+    return cachedMap;
+  }
+
+  const files = getFiles(cwd);
+  const lines: string[] = [];
+
+  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(): string {
+  return cachedMap;
+}
+
+/**
+ * Clear the cache
+ */
+export function clearMapCache(): void {
+  cachedMap = "";
+  cachedCwd = "";
+  cachedTime = 0;
+}
+
+/**
+ * Check if file is supported
+ */
+export function isSupportedFile(filePath: string): boolean {
+  return !!getLang(extname(filePath).toLowerCase());
+}
+
+export function getSupportedExtensions(): string[] {
+  return [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rs"];
+}
+
+export function getLanguageForExt(ext: string): string | null {
+  return getLang(ext);
+}

package/src/utils/sessions.ts

@@ -0,0 +1,222 @@
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { ChatCompletionMessageParam } from "openai/resources/chat/completions";
+
+const CONFIG_DIR = join(homedir(), ".codemaxxing");
+const DB_PATH = join(CONFIG_DIR, "sessions.db");
+
+let db: Database.Database | null = null;
+
+/**
+ * Initialize the database and create tables if needed
+ */
+function getDb(): Database.Database {
+  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(): string {
+  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: string, model: string): string {
+  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: string, message: ChatCompletionMessageParam): void {
+  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 as any).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) as { count: number };
+
+  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: string, tokens: number): void {
+  const db = getDb();
+  db.prepare(`
+    UPDATE sessions SET token_estimate = ? WHERE id = ?
+  `).run(tokens, sessionId);
+}
+
+/**
+ * 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 function listSessions(limit: number = 10): SessionInfo[] {
+  const db = getDb();
+  return db.prepare(`
+    SELECT * FROM sessions ORDER BY updated_at DESC LIMIT ?
+  `).all(limit) as SessionInfo[];
+}
+
+/**
+ * Load all messages for a session
+ */
+export function loadMessages(sessionId: string): ChatCompletionMessageParam[] {
+  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) as Array<{
+    role: string;
+    content: string | null;
+    tool_calls: string | null;
+    tool_call_id: string | null;
+  }>;
+
+  return rows.map((row) => {
+    const msg: any = { 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 as ChatCompletionMessageParam;
+  });
+}
+
+/**
+ * Get a specific session
+ */
+export function getSession(sessionId: string): SessionInfo | null {
+  const db = getDb();
+  return (db.prepare(`
+    SELECT * FROM sessions WHERE id = ?
+  `).get(sessionId) as SessionInfo) || null;
+}
+
+/**
+ * Delete a session and its messages
+ */
+export function deleteSession(sessionId: string): boolean {
+  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: string, summary: string): void {
+  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: string): SessionInfo | null {
+  const db = getDb();
+  return (db.prepare(`
+    SELECT * FROM sessions WHERE cwd = ? ORDER BY updated_at DESC LIMIT 1
+  `).get(cwd) as SessionInfo) || null;
+}
+
+/**
+ * Close the database connection
+ */
+export function closeDb(): void {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "resolveJsonModule": true,
+    "jsx": "react-jsx"
+  },
+  "include": ["src/**/*"]
+}