@cwim/kanban 1.1.19 → 1.2.0

package/dist/storage/store.js

@@ -1,12 +1,13 @@
-import { promises as fs, existsSync, mkdirSync } from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-const KANBAN_DIR = path.join(os.homedir(), '.kanban');
-const SESSIONS_DIR = path.join(KANBAN_DIR, 'sessions');
-const ACTIVE_SESSION_FILE = path.join(KANBAN_DIR, 'active-session.json');
-const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
-const OPENCODE_CONFIG_DIR = path.join(os.homedir(), '.config', 'opencode');
-const OPENCODE_DATA_DIR = path.join(os.homedir(), '.local', 'share', 'opencode');
+import { promises as fs, existsSync, mkdirSync } from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execSync } from "child_process";
+const KANBAN_DIR = path.join(os.homedir(), ".kanban");
+const SESSIONS_DIR = path.join(KANBAN_DIR, "sessions");
+const ACTIVE_SESSION_FILE = path.join(KANBAN_DIR, "active-session.json");
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");
+const OPENCODE_CONFIG_DIR = path.join(os.homedir(), ".config", "opencode");
+const OPENCODE_DATA_DIR = path.join(os.homedir(), ".local", "share", "opencode");
 function getDefaultData() {
     return {
         version: 1,
@@ -23,13 +24,13 @@ function getSessionDir(sessionName) {
     return path.join(SESSIONS_DIR, sessionName);
 }
 function getSessionDataFile(sessionName) {
-    return path.join(getSessionDir(sessionName), 'tasks.json');
+    return path.join(getSessionDir(sessionName), "tasks.json");
 }
 export async function getActiveSession() {
     try {
         if (!existsSync(ACTIVE_SESSION_FILE))
             return undefined;
-        const raw = await fs.readFile(ACTIVE_SESSION_FILE, 'utf-8');
+        const raw = await fs.readFile(ACTIVE_SESSION_FILE, "utf-8");
         const active = JSON.parse(raw);
         return active.name;
     }
@@ -43,21 +44,23 @@ export async function setActiveSession(sessionName) {
         name: sessionName,
         setAt: new Date().toISOString(),
     };
-    await fs.writeFile(ACTIVE_SESSION_FILE, JSON.stringify(active, null, 2), 'utf-8');
+    await fs.writeFile(ACTIVE_SESSION_FILE, JSON.stringify(active, null, 2), "utf-8");
 }
 // Session detection
 async function detectClaudeSessions() {
     try {
         if (!existsSync(CLAUDE_PROJECTS_DIR))
             return [];
-        const entries = await fs.readdir(CLAUDE_PROJECTS_DIR, { withFileTypes: true });
+        const entries = await fs.readdir(CLAUDE_PROJECTS_DIR, {
+            withFileTypes: true,
+        });
         return entries
             .filter((e) => e.isDirectory())
             .map((e) => ({
             name: e.name,
             path: path.join(CLAUDE_PROJECTS_DIR, e.name),
             detectedAt: new Date().toISOString(),
-            source: 'claude',
+            source: "claude",
         }));
     }
     catch {
@@ -65,28 +68,112 @@ async function detectClaudeSessions() {
     }
 }
 const OPENCODE_CONFIG_EXCLUDES = new Set([
-    'agents', 'commands', 'modes', 'plugins', 'skills', 'tools', 'themes', 'node_modules'
+    "agents",
+    "command",
+    "commands",
+    "modes",
+    "plugins",
+    "skills",
+    "tools",
+    "themes",
+    "node_modules",
 ]);
 const OPENCODE_DATA_EXCLUDES = new Set([
-    'bin', 'log', 'repos', 'snapshot', 'storage', 'tool-output'
+    "bin",
+    "log",
+    "repos",
+    "snapshot",
+    "storage",
+    "tool-output",
 ]);
 const ALL_INTERNAL_NAMES = new Set([
     ...OPENCODE_CONFIG_EXCLUDES,
     ...OPENCODE_DATA_EXCLUDES,
 ]);
 async function detectOpencodeSessions() {
+    // First, try to read from the OpenCode SQLite database (most accurate)
+    const dbSessions = await queryOpencodeDatabase();
+    if (dbSessions.length > 0) {
+        return dbSessions;
+    }
+    // Fallback: directory-based detection
+    return detectOpencodeSessionsFromDirectories();
+}
+async function queryOpencodeDatabase() {
+    const dbPath = path.join(OPENCODE_DATA_DIR, "opencode.db");
+    if (!existsSync(dbPath)) {
+        return [];
+    }
+    try {
+        // Query projects from the SQLite database
+        // worktree is the actual project path, name may be empty
+        const query = `SELECT id, worktree, name, time_updated FROM project WHERE worktree IS NOT NULL AND worktree != '/' ORDER BY time_updated DESC;`;
+        // Write query to temp file to avoid shell escaping issues with paths
+        const tempQueryFile = path.join(os.tmpdir(), `opencode-query-${Date.now()}.sql`);
+        await fs.writeFile(tempQueryFile, query, "utf-8");
+        let result;
+        try {
+            result = execSync(`sqlite3 "${dbPath}" < "${tempQueryFile}"`, {
+                encoding: "utf8",
+                timeout: 10000,
+            });
+        }
+        finally {
+            // Clean up temp file
+            try {
+                await fs.unlink(tempQueryFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        const sessions = [];
+        const seenPaths = new Set();
+        for (const line of result.trim().split("\n")) {
+            if (!line.trim())
+                continue;
+            const parts = line.split("|");
+            if (parts.length < 4)
+                continue;
+            const [, worktree, name, timeUpdated] = parts;
+            if (!worktree || worktree === "/")
+                continue;
+            // Normalize path for deduplication
+            const normalizedPath = path.normalize(worktree);
+            if (seenPaths.has(normalizedPath))
+                continue;
+            seenPaths.add(normalizedPath);
+            // Use project name if available, otherwise basename of path
+            const sessionName = name?.trim() || path.basename(normalizedPath);
+            sessions.push({
+                name: sessionName,
+                path: normalizedPath,
+                detectedAt: new Date(parseInt(timeUpdated)).toISOString(),
+                source: "opencode",
+            });
+        }
+        return sessions;
+    }
+    catch {
+        // If SQLite query fails, return empty to trigger fallback
+        return [];
+    }
+}
+async function detectOpencodeSessionsFromDirectories() {
     const sessions = [];
     // Check ~/.config/opencode/ for project directories
     try {
         if (existsSync(OPENCODE_CONFIG_DIR)) {
-            const entries = await fs.readdir(OPENCODE_CONFIG_DIR, { withFileTypes: true });
+            const entries = await fs.readdir(OPENCODE_CONFIG_DIR, {
+                withFileTypes: true,
+            });
             for (const entry of entries) {
                 if (entry.isDirectory() && !OPENCODE_CONFIG_EXCLUDES.has(entry.name)) {
                     sessions.push({
                         name: entry.name,
                         path: path.join(OPENCODE_CONFIG_DIR, entry.name),
                         detectedAt: new Date().toISOString(),
-                        source: 'opencode',
+                        source: "opencode",
                     });
                 }
             }
@@ -98,17 +185,19 @@ async function detectOpencodeSessions() {
     // Check ~/.local/share/opencode/ for session data
     try {
         if (existsSync(OPENCODE_DATA_DIR)) {
-            const entries = await fs.readdir(OPENCODE_DATA_DIR, { withFileTypes: true });
+            const entries = await fs.readdir(OPENCODE_DATA_DIR, {
+                withFileTypes: true,
+            });
             for (const entry of entries) {
                 if (entry.isDirectory() && !OPENCODE_DATA_EXCLUDES.has(entry.name)) {
                     const sessionName = entry.name;
                     // Only add if not already found
-                    if (!sessions.some(s => s.name === sessionName)) {
+                    if (!sessions.some((s) => s.name === sessionName)) {
                         sessions.push({
                             name: sessionName,
                             path: path.join(OPENCODE_DATA_DIR, entry.name),
                             detectedAt: new Date().toISOString(),
-                            source: 'opencode',
+                            source: "opencode",
                         });
                     }
                 }
@@ -120,22 +209,58 @@ async function detectOpencodeSessions() {
     }
     return sessions;
 }
+function detectGitRepo() {
+    try {
+        const cwd = process.cwd();
+        const gitRoot = execSync("git rev-parse --show-toplevel", {
+            cwd,
+            encoding: "utf8",
+            timeout: 5000,
+            stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+        if (!gitRoot)
+            return undefined;
+        const normalizedPath = path.normalize(gitRoot);
+        const name = path.basename(normalizedPath);
+        return { name, path: normalizedPath };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function detectGitRepoSessions() {
+    const repo = detectGitRepo();
+    if (!repo)
+        return [];
+    return [
+        {
+            name: repo.name,
+            path: repo.path,
+            detectedAt: new Date().toISOString(),
+            source: "git",
+        },
+    ];
+}
 export async function detectSessions() {
     try {
-        // Detect sessions from both Claude and opencode
-        const [claudeSessions, opencodeSessions] = await Promise.all([
+        // Detect sessions from all sources: Git (CWD), Claude, and OpenCode
+        const [gitSessions, claudeSessions, opencodeSessions] = await Promise.all([
+            detectGitRepoSessions(),
             detectClaudeSessions(),
             detectOpencodeSessions(),
         ]);
         // Merge and deduplicate by name
+        // Priority: Git > Claude > OpenCode
         const sessionMap = new Map();
+        for (const session of opencodeSessions) {
+            sessionMap.set(session.name, session);
+        }
         for (const session of claudeSessions) {
             sessionMap.set(session.name, session);
         }
-        for (const session of opencodeSessions) {
-            if (!sessionMap.has(session.name)) {
-                sessionMap.set(session.name, session);
-            }
+        // Git sessions take highest priority - they reflect the actual working directory
+        for (const session of gitSessions) {
+            sessionMap.set(session.name, session);
         }
         const sessions = Array.from(sessionMap.values());
         if (sessions.length === 0)
@@ -164,6 +289,12 @@ export async function detectSessions() {
 }
 export async function detectLatestSession() {
     const sessions = await detectSessions();
+    // If we're in a git repo, prefer the git-detected session
+    // even if it's not the most recently modified
+    const gitSession = sessions.find((s) => s.source === "git");
+    if (gitSession) {
+        return gitSession;
+    }
     return sessions[0];
 }
 export async function listAllSessions() {
@@ -177,13 +308,13 @@ export async function listAllSessions() {
         for (const entry of entries) {
             if (entry.isDirectory() &&
                 !detectedNames.has(entry.name) &&
-                entry.name !== 'independent' &&
+                entry.name !== "independent" &&
                 !ALL_INTERNAL_NAMES.has(entry.name)) {
                 storedSessions.push({
                     name: entry.name,
                     path: getSessionDir(entry.name),
                     detectedAt: new Date().toISOString(),
-                    source: 'manual',
+                    source: "manual",
                 });
             }
         }
@@ -193,10 +324,10 @@ export async function listAllSessions() {
         ...detected,
         ...storedSessions,
         {
-            name: 'independent',
-            path: getSessionDir('independent'),
+            name: "independent",
+            path: getSessionDir("independent"),
             detectedAt: new Date().toISOString(),
-            source: 'independent',
+            source: "independent",
         },
     ];
     return allSessions;
@@ -213,15 +344,15 @@ export async function getCurrentSessionName() {
         return latest.name;
     }
     // Fallback to independent
-    await setActiveSession('independent');
-    return 'independent';
+    await setActiveSession("independent");
+    return "independent";
 }
 // Per-session data operations
 async function readSessionData(sessionName) {
     const dataFile = getSessionDataFile(sessionName);
     ensureDir(getSessionDir(sessionName));
     try {
-        const raw = await fs.readFile(dataFile, 'utf-8');
+        const raw = await fs.readFile(dataFile, "utf-8");
         return JSON.parse(raw);
     }
     catch {
@@ -234,13 +365,13 @@ async function writeSessionData(sessionName, data) {
     const dataFile = getSessionDataFile(sessionName);
     ensureDir(getSessionDir(sessionName));
     data.updatedAt = new Date().toISOString();
-    const tempFile = dataFile + '.tmp';
-    await fs.writeFile(tempFile, JSON.stringify(data, null, 2), 'utf-8');
+    const tempFile = dataFile + ".tmp";
+    await fs.writeFile(tempFile, JSON.stringify(data, null, 2), "utf-8");
     await fs.rename(tempFile, dataFile);
 }
 // Task CRUD (session-aware)
 export async function listTasks(sessionName, filter) {
-    const targetSession = sessionName ?? await getCurrentSessionName();
+    const targetSession = sessionName ?? (await getCurrentSessionName());
     const data = await readSessionData(targetSession);
     let tasks = data.tasks;
     if (filter?.status) {
@@ -257,20 +388,20 @@ export async function listTasks(sessionName, filter) {
     return tasks;
 }
 export async function getTask(id, sessionName) {
-    const targetSession = sessionName ?? await getCurrentSessionName();
+    const targetSession = sessionName ?? (await getCurrentSessionName());
     const data = await readSessionData(targetSession);
     return data.tasks.find((t) => t.id === id);
 }
 export async function createTask(input, sessionName) {
-    const targetSession = sessionName ?? await getCurrentSessionName();
+    const targetSession = sessionName ?? (await getCurrentSessionName());
     const data = await readSessionData(targetSession);
     const task = {
         id: generateId(),
         title: input.title,
         description: input.description,
-        status: input.status ?? 'todo',
+        status: input.status ?? "todo",
         tags: input.tags ?? [],
-        source: input.source ?? 'manual',
+        source: input.source ?? "manual",
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
     };
@@ -279,7 +410,7 @@ export async function createTask(input, sessionName) {
     return task;
 }
 export async function updateTask(id, input, sessionName) {
-    const targetSession = sessionName ?? await getCurrentSessionName();
+    const targetSession = sessionName ?? (await getCurrentSessionName());
     const data = await readSessionData(targetSession);
     const idx = data.tasks.findIndex((t) => t.id === id);
     if (idx === -1)
@@ -301,7 +432,7 @@ export async function moveTask(id, status, sessionName) {
     return updateTask(id, { status }, sessionName);
 }
 export async function deleteTask(id, sessionName) {
-    const targetSession = sessionName ?? await getCurrentSessionName();
+    const targetSession = sessionName ?? (await getCurrentSessionName());
     const data = await readSessionData(targetSession);
     const initialLen = data.tasks.length;
     data.tasks = data.tasks.filter((t) => t.id !== id);
@@ -311,7 +442,7 @@ export async function deleteTask(id, sessionName) {
     return true;
 }
 export async function appendNote(id, note, sessionName) {
-    const targetSession = sessionName ?? await getCurrentSessionName();
+    const targetSession = sessionName ?? (await getCurrentSessionName());
     const data = await readSessionData(targetSession);
     const idx = data.tasks.findIndex((t) => t.id === id);
     if (idx === -1)
@@ -327,7 +458,7 @@ export async function appendNote(id, note, sessionName) {
     return task;
 }
 export async function getAllData(sessionName) {
-    const targetSession = sessionName ?? await getCurrentSessionName();
+    const targetSession = sessionName ?? (await getCurrentSessionName());
     const data = await readSessionData(targetSession);
     // Attach session info
     const sessions = await listAllSessions();
@@ -338,7 +469,128 @@ export async function getAllData(sessionName) {
     return data;
 }
 const STOP_WORDS = new Set([
-    'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had', 'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'its', 'may', 'new', 'now', 'old', 'see', 'two', 'who', 'boy', 'did', 'she', 'use', 'her', 'way', 'many', 'oil', 'sit', 'set', 'run', 'eat', 'far', 'sea', 'eye', 'ago', 'off', 'too', 'any', 'say', 'man', 'try', 'ask', 'end', 'why', 'let', 'put', 'say', 'she', 'try', 'way', 'own', 'say', 'too', 'old', 'tell', 'very', 'when', 'much', 'would', 'there', 'their', 'what', 'said', 'each', 'which', 'will', 'about', 'could', 'other', 'after', 'first', 'never', 'these', 'think', 'where', 'being', 'every', 'great', 'might', 'shall', 'still', 'those', 'while', 'this', 'that', 'with', 'have', 'from', 'they', 'know', 'want', 'been', 'good', 'much', 'some', 'time', 'very', 'when', 'come', 'here', 'just', 'like', 'long', 'make', 'many', 'over', 'such', 'take', 'than', 'them', 'well', 'were'
+    "the",
+    "and",
+    "for",
+    "are",
+    "but",
+    "not",
+    "you",
+    "all",
+    "can",
+    "had",
+    "her",
+    "was",
+    "one",
+    "our",
+    "out",
+    "day",
+    "get",
+    "has",
+    "him",
+    "his",
+    "how",
+    "its",
+    "may",
+    "new",
+    "now",
+    "old",
+    "see",
+    "two",
+    "who",
+    "boy",
+    "did",
+    "she",
+    "use",
+    "her",
+    "way",
+    "many",
+    "oil",
+    "sit",
+    "set",
+    "run",
+    "eat",
+    "far",
+    "sea",
+    "eye",
+    "ago",
+    "off",
+    "too",
+    "any",
+    "say",
+    "man",
+    "try",
+    "ask",
+    "end",
+    "why",
+    "let",
+    "put",
+    "say",
+    "she",
+    "try",
+    "way",
+    "own",
+    "say",
+    "too",
+    "old",
+    "tell",
+    "very",
+    "when",
+    "much",
+    "would",
+    "there",
+    "their",
+    "what",
+    "said",
+    "each",
+    "which",
+    "will",
+    "about",
+    "could",
+    "other",
+    "after",
+    "first",
+    "never",
+    "these",
+    "think",
+    "where",
+    "being",
+    "every",
+    "great",
+    "might",
+    "shall",
+    "still",
+    "those",
+    "while",
+    "this",
+    "that",
+    "with",
+    "have",
+    "from",
+    "they",
+    "know",
+    "want",
+    "been",
+    "good",
+    "much",
+    "some",
+    "time",
+    "very",
+    "when",
+    "come",
+    "here",
+    "just",
+    "like",
+    "long",
+    "make",
+    "many",
+    "over",
+    "such",
+    "take",
+    "than",
+    "them",
+    "well",
+    "were",
 ]);
 function extractKeywords(text) {
     return text
@@ -350,9 +602,9 @@ function extractKeywords(text) {
 function getTaskFields(task) {
     return {
         title: task.title.toLowerCase(),
-        tags: task.tags.join(' ').toLowerCase(),
-        description: (task.description || '').toLowerCase(),
-        notes: (task.notes || []).join(' ').toLowerCase(),
+        tags: task.tags.join(" ").toLowerCase(),
+        description: (task.description || "").toLowerCase(),
+        notes: (task.notes || []).join(" ").toLowerCase(),
     };
 }
 function scoreTask(task, queryWords) {
@@ -365,7 +617,7 @@ function scoreTask(task, queryWords) {
         if (fields.title.includes(word)) {
             score += 5;
             signals++;
-            reasons.push({ field: 'title', matched: word });
+            reasons.push({ field: "title", matched: word });
             break; // Only count title once per word
         }
     }
@@ -374,7 +626,7 @@ function scoreTask(task, queryWords) {
         if (fields.tags.includes(word)) {
             score += 4;
             signals++;
-            reasons.push({ field: 'tag', matched: word });
+            reasons.push({ field: "tag", matched: word });
             break;
         }
     }
@@ -383,7 +635,7 @@ function scoreTask(task, queryWords) {
         if (fields.description.includes(word)) {
             score += 2;
             signals++;
-            reasons.push({ field: 'description', matched: word });
+            reasons.push({ field: "description", matched: word });
             break;
         }
     }
@@ -392,7 +644,7 @@ function scoreTask(task, queryWords) {
         if (fields.notes.includes(word)) {
             score += 1;
             signals++;
-            reasons.push({ field: 'notes', matched: word });
+            reasons.push({ field: "notes", matched: word });
             break;
         }
     }
@@ -406,25 +658,25 @@ function scoreTask(task, queryWords) {
         score += 1;
     }
     // Status boost
-    if (task.status === 'in-progress') {
+    if (task.status === "in-progress") {
         score += 2;
         signals++;
     }
-    else if (task.status === 'blocked') {
+    else if (task.status === "blocked") {
         score += 1;
         signals++;
     }
     return { task, score, signals, reasons };
 }
 export async function recallTasks(context, limit = 5, sessionName) {
-    const targetSession = sessionName ?? await getCurrentSessionName();
+    const targetSession = sessionName ?? (await getCurrentSessionName());
     const data = await readSessionData(targetSession);
     if (data.tasks.length === 0) {
         return {
             relevant: [],
             reasons: new Map(),
             summary: { active: 0, done: 0, blocked: 0, total: 0 },
-            quality: 'poor',
+            quality: "poor",
         };
     }
     const queryWords = extractKeywords(context);
@@ -437,19 +689,19 @@ export async function recallTasks(context, limit = 5, sessionName) {
     let quality;
     let actualLimit;
     if (maxScore >= 10) {
-        quality = 'excellent';
+        quality = "excellent";
         actualLimit = Math.min(limit, 2);
     }
     else if (maxScore >= 7) {
-        quality = 'good';
+        quality = "good";
         actualLimit = Math.min(limit, 3);
     }
     else if (maxScore >= 5) {
-        quality = 'fair';
+        quality = "fair";
         actualLimit = 1;
     }
     else {
-        quality = 'poor';
+        quality = "poor";
         actualLimit = 0;
     }
     // Filter by minimum threshold and signal count
@@ -460,9 +712,9 @@ export async function recallTasks(context, limit = 5, sessionName) {
     const reasons = new Map(filtered.map((s) => [s.task.id, s.reasons]));
     // Calculate summary
     const summary = {
-        active: data.tasks.filter((t) => t.status === 'in-progress').length,
-        done: data.tasks.filter((t) => t.status === 'done').length,
-        blocked: data.tasks.filter((t) => t.status === 'blocked').length,
+        active: data.tasks.filter((t) => t.status === "in-progress").length,
+        done: data.tasks.filter((t) => t.status === "done").length,
+        blocked: data.tasks.filter((t) => t.status === "blocked").length,
         total: data.tasks.length,
     };
     return { relevant, reasons, summary, quality };