@polderlabs/openkan 0.4.0

package/dist/kanban/projects.js

@@ -0,0 +1,545 @@
+// OpenKan — multi-project registry stored at ~/.config/openkan/projects.json
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { join, basename, resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+// ─── Registry path ─────────────────────────────────────────────────────────────
+let _testingRegistryPath = null;
+export function setRegistryPathForTesting(p) {
+    _testingRegistryPath = p;
+}
+export function registryPath() {
+    if (_testingRegistryPath)
+        return _testingRegistryPath;
+    const configDir = join(homedir(), ".config", "openkan");
+    return join(configDir, "projects.json");
+}
+// ─── Low-level load/save ──────────────────────────────────────────────────────
+export function loadRegistry() {
+    const path = registryPath();
+    if (!existsSync(path))
+        return { projects: [] };
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return { projects: [] };
+    }
+}
+export function saveRegistry(reg) {
+    const path = registryPath();
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(reg, null, 2), "utf-8");
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+function canonicalRoot(root) {
+    try {
+        return realpathSync(resolve(root));
+    }
+    catch {
+        return resolve(root);
+    }
+}
+function uniqueId(id, used) {
+    const base = id || "project";
+    let candidate = base;
+    for (let i = 2; used.has(candidate); i++)
+        candidate = `${base}-${i}`;
+    return candidate;
+}
+function distinctProjects(projects) {
+    const roots = new Map();
+    for (const project of projects) {
+        const root = canonicalRoot(project.root);
+        const prior = roots.get(root);
+        if (!prior)
+            roots.set(root, { ...project, root });
+        else
+            roots.set(root, {
+                ...(project.active ? project : prior), root,
+                active: prior.active || project.active,
+                lastOpenedAt: [prior.lastOpenedAt, project.lastOpenedAt].filter(Boolean).sort().at(-1),
+            });
+    }
+    const ids = new Set();
+    return [...roots.values()].map(project => {
+        const id = uniqueId(project.id, ids);
+        ids.add(id);
+        return { ...project, id };
+    });
+}
+function projectActivity(project) {
+    let latest = Date.parse(project.lastOpenedAt || project.addedAt) || 0;
+    const files = [".ok/board.json", ".ok/tasks", ".ok/plans", ".ok/prds", ".ok/changelog.jsonl", ".git/index", ".git/logs/HEAD"];
+    // Session turns append to existing files; inspect mtimes, never transcript contents.
+    try {
+        for (const name of readdirSync(join(project.root, ".ok/sessions")))
+            files.push(`.ok/sessions/${name}`);
+    }
+    catch { /* no sessions */ }
+    for (const file of files) {
+        try {
+            latest = Math.max(latest, statSync(join(project.root, file)).mtimeMs);
+        }
+        catch { /* optional activity source */ }
+    }
+    return Math.min(latest, Date.now());
+}
+/** List one entry per physical repository, newest activity first. */
+export function listProjects() {
+    // Claude worktrees are execution sandboxes, not independent OpenKan
+    // projects. Keep legacy registry entries on disk for compatibility, but
+    // never surface them in selectors or overview APIs.
+    return distinctProjects(loadRegistry().projects)
+        .filter((project) => !isWorktreePath(project.root))
+        .map(project => ({ ...project, lastActivityAt: new Date(projectActivity(project)).toISOString() }))
+        .sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt) || a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+}
+export function isWorktreePath(root) {
+    const path = root.replace(/\\/g, "/").toLowerCase();
+    if (path.includes("/.claude/worktrees/") || path.includes("/.git/worktrees/") || /\/worktrees\/[^/]+$/.test(path) || /\/(?:wt|worktree)-/i.test(path))
+        return true;
+    // Linked Git worktrees store `.git` as a text file pointing into the main
+    // repository's `.git/worktrees/<name>` directory, even when their own root
+    // has an innocuous name such as `wt-feature`.
+    try {
+        const git = join(root, ".git");
+        if (existsSync(git) && statSync(git).isFile()) {
+            return /gitdir:\s+.*[\\/]\.git[\\/]worktrees[\\/]/i.test(readFileSync(git, "utf-8"));
+        }
+    }
+    catch { /* unreadable entries remain eligible projects */ }
+    return false;
+}
+/** Return the currently active project, or null. */
+export function activeProject() {
+    return listProjects().find(p => p.active) ?? null;
+}
+/**
+ * Set the active project by id.
+ * Returns the PREVIOUS active project (or null if none was active).
+ * Returns null if the id doesn't exist.
+ */
+export function setActiveProject(id) {
+    const reg = { projects: distinctProjects(loadRegistry().projects) };
+    const prev = reg.projects.find(p => p.active) ?? null;
+    const target = reg.projects.find(p => p.id === id);
+    if (!target)
+        return null;
+    reg.projects = reg.projects.map(p => ({ ...p, active: p.id === id, ...(p.id === id ? { lastOpenedAt: new Date().toISOString() } : {}) }));
+    saveRegistry(reg);
+    return prev;
+}
+/**
+ * Add a new project to the registry.
+ * Auto-derives `id` from `root` basename if not provided.
+ * Sets it as active (deactivates any previous).
+ */
+export function addProject(input) {
+    const root = canonicalRoot(input.root);
+    const now = new Date().toISOString();
+    const reg = { projects: distinctProjects(loadRegistry().projects) };
+    const existing = reg.projects.find(project => project.root === root);
+    const id = existing?.id ?? uniqueId(input.id ?? slugify(basename(root)), new Set(reg.projects.map(project => project.id)));
+    const entry = {
+        ...existing, id, name: input.name, root,
+        addedAt: existing?.addedAt || now, lastOpenedAt: now, active: true,
+    };
+    reg.projects = reg.projects.filter(project => project.root !== root).map(project => ({ ...project, active: false }));
+    reg.projects.push(entry);
+    saveRegistry(reg);
+    return entry;
+}
+/** Remove a project by id. Returns true if found and removed. */
+export function removeProject(id) {
+    const reg = { projects: distinctProjects(loadRegistry().projects) };
+    const idx = reg.projects.findIndex(p => p.id === id);
+    if (idx === -1)
+        return false;
+    const wasActive = reg.projects[idx].active;
+    reg.projects.splice(idx, 1);
+    // If removed was active, activate the first remaining (or none)
+    if (wasActive && reg.projects.length > 0) {
+        reg.projects[0].active = true;
+    }
+    saveRegistry(reg);
+    return true;
+}
+/**
+ * Resolve a project's openkan dir. Returns null if root doesn't exist.
+ * Returns <root>/.ok
+ */
+export function projectKanbanDir(p) {
+    if (!existsSync(p.root))
+        return null;
+    return join(p.root, ".ok");
+}
+/**
+ * Resolve a project kanban directory by either project id (`openkan`,
+ * `sample-kanban-project`) or absolute project root path. Returns null
+ * when no matching registered project exists. This is the supported
+ * cross-project lookup used by cross-project task move.
+ */
+export function resolveProjectKanbanDir(ref) {
+    // Try by id first.
+    const byId = listProjects().find((p) => p.id === ref);
+    if (byId)
+        return projectKanbanDir(byId);
+    // Fall back to root path match.
+    const normalised = resolve(ref);
+    const byRoot = listProjects().find((p) => resolve(p.root) === normalised);
+    if (byRoot)
+        return projectKanbanDir(byRoot);
+    return null;
+}
+/** Find a registered project entry by id (case-insensitive). Returns null when missing. */
+export function findProject(id) {
+    if (!id)
+        return null;
+    return listProjects().find((p) => p.id === id) ?? null;
+}
+/**
+ * Resolve a target `.ok/` directory from a project id, project root path,
+ * or an already-absolute `.ok/` directory. When the supplied ref points
+ * directly at a directory that already contains a `.ok/` subdir, that
+ * subdir wins — callers usually want the kanban root, not the project
+ * root. Falls back to the conventional `<root>/.ok` layout.
+ */
+export function resolveKanbanDir(ref) {
+    if (!ref)
+        return ref;
+    const nested = join(ref, ".ok");
+    if (existsSync(nested) && statSync(nested).isDirectory())
+        return nested;
+    // Registry lookup by id or root path.
+    const resolved = resolveProjectKanbanDir(ref);
+    if (resolved)
+        return resolved;
+    // Bare `.ok/` path.
+    if (existsSync(ref) && statSync(ref).isDirectory())
+        return ref;
+    return nested;
+}
+// ─── Auto-detect helpers ──────────────────────────────────────────────────────
+const DEFAULT_SKIP_DIRS = new Set([
+    "node_modules", ".git", "dist", ".next",
+    ".cache", ".npm", ".local", ".config", "openkan-test",
+]);
+/**
+ * Walk upward from `cwd` looking for a `.git` file or directory.
+ * Returns the repo root (parent of `.git`) or null if not found.
+ */
+export async function findClosestGitRepo(cwd) {
+    let dir = resolve(cwd);
+    const root = resolve("/");
+    while (dir !== root) {
+        try {
+            const stat = statSync(join(dir, ".git"));
+            if (stat.isDirectory() || stat.isFile()) {
+                return dir;
+            }
+        }
+        catch {
+            // No .git here, walk up
+        }
+        const parent = resolve(dir, "..");
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Synchronous walk of `dir` up to `maxDepth` levels, returning git repo roots.
+ * Respects skipHidden and skipDirs options.
+ */
+function walkForGitRepos(dir, maxDepth, currentDepth, skipHidden, skipDirs, results, maxResults) {
+    if (results.length >= maxResults)
+        return;
+    if (currentDepth > maxDepth)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (results.length >= maxResults)
+            break;
+        // Check hidden
+        if (skipHidden && entry.startsWith("."))
+            continue;
+        // Check skip dirs
+        if (skipDirs.has(entry))
+            continue;
+        const fullPath = join(dir, entry);
+        let stat;
+        try {
+            stat = statSync(fullPath);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            // Check if it's a git repo directly
+            const gitPath = join(fullPath, ".git");
+            let isGitRepo = false;
+            try {
+                const gitStat = statSync(gitPath);
+                isGitRepo = gitStat.isDirectory() || gitStat.isFile();
+            }
+            catch {
+                // Not a git repo
+            }
+            if (isGitRepo) {
+                results.push(fullPath);
+                // Don't recurse into git repos
+                continue;
+            }
+            // Recurse into subdirectories (at next depth level)
+            if (currentDepth < maxDepth) {
+                walkForGitRepos(fullPath, maxDepth, currentDepth + 1, skipHidden, skipDirs, results, maxResults);
+            }
+        }
+    }
+}
+/**
+ * Scan common locations for git repositories.
+ * Returns the list of discovered repo root paths (not deduplicated).
+ */
+export async function scanForGitRepos(opts) {
+    const homes = opts?.homes ?? [homedir()];
+    const suffixes = opts?.suffixes ?? ["projects", "work", "repos", "src", "code", "Documents"];
+    const maxDepth = opts?.maxDepth ?? 2;
+    const maxResults = opts?.maxResults ?? 50;
+    const skipHidden = opts?.skipHidden ?? true;
+    const skipDirs = new Set(opts?.skipDirs ?? [...DEFAULT_SKIP_DIRS]);
+    const results = [];
+    // Start from cwd
+    const cwd = process.cwd();
+    const cwdRepo = await findClosestGitRepo(cwd);
+    if (cwdRepo)
+        results.push(cwdRepo);
+    // Walk each home directory's suffixes
+    for (const home of homes) {
+        for (const suffix of suffixes) {
+            if (results.length >= maxResults)
+                break;
+            const dir = join(home, suffix);
+            try {
+                if (!statSync(dir).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            walkForGitRepos(dir, maxDepth, 0, skipHidden, skipDirs, results, maxResults);
+        }
+    }
+    return results;
+}
+/**
+ * Auto-detect git repositories and register new ones in the project registry.
+ * Does NOT make any project active; does NOT modify existing entries.
+ */
+export async function autoDetectProjects(opts) {
+    const homes = opts?.homes ?? [homedir()];
+    const suffixes = opts?.suffixes ?? ["projects", "work", "repos", "src", "code", "Documents"];
+    const maxDepth = opts?.maxDepth ?? 2;
+    const maxResults = opts?.maxResults ?? 50;
+    const skipHidden = opts?.skipHidden ?? true;
+    const skipDirs = new Set(opts?.skipDirs ?? [...DEFAULT_SKIP_DIRS]);
+    const registry = { projects: distinctProjects(loadRegistry().projects) };
+    const knownRoots = new Set(registry.projects.map((p) => canonicalRoot(p.root)));
+    const result = { scanned: [], discovered: [], alreadyKnown: [] };
+    // Start from cwd
+    const cwd = process.cwd();
+    const cwdRepo = await findClosestGitRepo(cwd);
+    if (cwdRepo)
+        result.scanned.push(cwdRepo);
+    // Walk each home directory's suffixes
+    for (const home of homes) {
+        for (const suffix of suffixes) {
+            if (result.scanned.length >= maxResults)
+                break;
+            const dir = join(home, suffix);
+            try {
+                if (!statSync(dir).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            walkForGitRepos(dir, maxDepth, 0, skipHidden, skipDirs, result.scanned, maxResults);
+        }
+    }
+    // Deduplicate scanned by resolved path BEFORE the loop that adds to registry.
+    // This prevents the same repo (found via cwd + suffix-walk overlap, or via
+    // multiple suffix iterations pointing to the same physical directory) from
+    // being registered multiple times in a single run.
+    const seenRoots = new Set();
+    const uniqueScanned = [];
+    for (const raw of result.scanned) {
+        const resolved = canonicalRoot(raw);
+        if (seenRoots.has(resolved))
+            continue;
+        seenRoots.add(resolved);
+        uniqueScanned.push(resolved); // store resolved form for consistency
+    }
+    // Filter against registry
+    for (const repoRoot of uniqueScanned) {
+        if (isWorktreePath(repoRoot))
+            continue;
+        if (knownRoots.has(repoRoot)) {
+            result.alreadyKnown.push(repoRoot);
+            continue;
+        }
+        const id = uniqueId(slugify(basename(repoRoot)), new Set([...registry.projects, ...result.discovered].map(project => project.id)));
+        const entry = {
+            id,
+            name: basename(repoRoot),
+            root: repoRoot,
+            addedAt: new Date().toISOString(),
+            active: false,
+        };
+        result.discovered.push(entry);
+        if (result.discovered.length >= maxResults)
+            break;
+    }
+    // Persist new discoveries
+    if (result.discovered.length > 0) {
+        registry.projects = [...registry.projects, ...result.discovered];
+        saveRegistry(registry);
+    }
+    return result;
+}
+// ─── Active project root resolution ──────────────────────────────────────────
+/**
+ * Return the active project's root, or process.cwd() if none is set
+ * or the active root doesn't exist on disk.
+ */
+export function getActiveProjectRoot() {
+    const active = activeProject();
+    if (!active)
+        return process.cwd();
+    if (!existsSync(active.root))
+        return process.cwd();
+    return active.root;
+}
+/**
+ * Clean the registry:
+ * - Dedup by resolved root (keep first occurrence, or one with active:true if tie)
+ * - Dedup by id (same tiebreaker)
+ * - Optionally prune entries whose root no longer exists on disk
+ * - Optionally persist the cleaned registry
+ */
+export function cleanupRegistry(opts) {
+    const verbose = opts?.verbose ?? false;
+    const pruneMissing = opts?.pruneMissing ?? false;
+    const persist = opts?.persist ?? false;
+    const reg = loadRegistry();
+    const before = reg.projects;
+    if (verbose)
+        console.error(`[cleanupRegistry] before: ${before.length} entries`);
+    // Phase 1: dedup by resolved root — keep first (or active:true) occurrence
+    const rootSeen = new Map();
+    const rootDeduped = []; // indices of duplicates
+    for (let i = 0; i < before.length; i++) {
+        const resolved = resolve(before[i].root);
+        const existing = rootSeen.get(resolved);
+        if (!existing) {
+            rootSeen.set(resolved, before[i]);
+        }
+        else {
+            // Keep the one with active:true if there's a tie
+            if (existing.active && !before[i].active) {
+                // existing wins — mark current as dup
+                rootDeduped.push(i);
+                if (verbose)
+                    console.error(`[cleanupRegistry] root dedup: ${resolved} (kept existing active)`);
+            }
+            else if (!existing.active && before[i].active) {
+                // current wins — replace
+                rootSeen.set(resolved, before[i]);
+                rootDeduped.push(i);
+                if (verbose)
+                    console.error(`[cleanupRegistry] root dedup: ${resolved} (replaced with active)`);
+            }
+            else {
+                // Neither active or both active — keep first, mark current as dup
+                rootDeduped.push(i);
+                if (verbose)
+                    console.error(`[cleanupRegistry] root dedup: ${resolved} (kept first)`);
+            }
+        }
+    }
+    let after = before.filter((_, i) => !rootDeduped.includes(i));
+    // Phase 2: dedup by id — keep first (or active:true)
+    const idSeen = new Map();
+    const idDeduped = [];
+    for (let i = 0; i < after.length; i++) {
+        const entry = after[i];
+        const existing = idSeen.get(entry.id);
+        if (!existing) {
+            idSeen.set(entry.id, entry);
+        }
+        else {
+            // Same id but different root — tiebreak by active
+            if (existing.active && !entry.active) {
+                idDeduped.push(i);
+                if (verbose)
+                    console.error(`[cleanupRegistry] id dedup: ${entry.id} (kept existing active)`);
+            }
+            else if (!existing.active && entry.active) {
+                idSeen.set(entry.id, entry);
+                idDeduped.push(i);
+                if (verbose)
+                    console.error(`[cleanupRegistry] id dedup: ${entry.id} (replaced with active)`);
+            }
+            else {
+                idDeduped.push(i);
+                if (verbose)
+                    console.error(`[cleanupRegistry] id dedup: ${entry.id} (kept first)`);
+            }
+        }
+    }
+    after = after.filter((_, i) => !idDeduped.includes(i));
+    // Phase 3: optional prune of missing roots
+    let pruned = 0;
+    if (pruneMissing) {
+        const beforeCount = after.length;
+        after = after.filter(p => {
+            const exists = existsSync(p.root);
+            if (!exists && verbose)
+                console.error(`[cleanupRegistry] prune: ${p.root} does not exist`);
+            return exists;
+        });
+        pruned = beforeCount - after.length;
+    }
+    if (verbose) {
+        console.error(`[cleanupRegistry] after: ${after.length} entries`);
+        console.error(`[cleanupRegistry] deduped: ${rootDeduped.length + idDeduped.length}`);
+        console.error(`[cleanupRegistry] pruned: ${pruned}`);
+    }
+    if (persist) {
+        saveRegistry({ projects: after });
+        if (verbose)
+            console.error(`[cleanupRegistry] persisted cleaned registry to ${registryPath()}`);
+    }
+    return {
+        before,
+        after,
+        removed: before.length - after.length,
+        deduped: rootDeduped.length + idDeduped.length,
+        pruned,
+    };
+}

package/dist/kanban/search.js

@@ -0,0 +1,121 @@
+// OpenKan — pure indexed text search across tasks.
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { getBoard } from "./board.js";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+/** Case-insensitive substring check. */
+function matches(haystack, needle) {
+    return haystack.toLowerCase().includes(needle.toLowerCase());
+}
+/** Load raw MDX content for a task, or "" if not found. */
+function loadMdxContent(kanbanDir, task) {
+    const mdxPath = join(kanbanDir, task.artifacts.mdxPath);
+    if (!existsSync(mdxPath))
+        return "";
+    try {
+        return readFileSync(mdxPath, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+/** Find which fields in the task match the query string. */
+function findMatchIn(task, query, mdxContent) {
+    const fields = [];
+    const q = query.toLowerCase();
+    if (matches(task.title, q))
+        fields.push("title");
+    if (matches(task.description, q))
+        fields.push("description");
+    if (task.tags?.some(t => matches(t, q)))
+        fields.push("tags");
+    if (task.assignees?.some(a => matches(a, q)))
+        fields.push("assignees");
+    if (matches(mdxContent, q))
+        fields.push("content");
+    return fields;
+}
+// ─── Core search ────────────────────────────────────────────────────────────
+/**
+ * Pure search across all tasks.
+ *
+ * Matching:
+ * - `query` — matches against title, description, tags, assignees, and MDX content
+ *   (case-insensitive substring on each field)
+ * - `column` — filters to that column (default: all)
+ * - `tags` — AND filter: task must contain ALL listed tags
+ * - `assignee` — task must have this name in assignees
+ * - `priority` — must match (or "all" to skip)
+ * - `category` — must match (or "all" to skip)
+ * - `archived` — include archived tasks (default: false)
+ * - `limit/offset` — pagination
+ *
+ * Returns tasks with a `matchIn` array listing which fields the query matched.
+ */
+export async function search(opts) {
+    const { kanbanDir, query = "", column, tags, assignee, priority, category, archived = false, limit = 50, offset = 0, } = opts;
+    const board = await getBoard();
+    // Pre-load MDX content for all tasks (avoids N sequential reads)
+    const mdxCache = new Map();
+    if (query) {
+        for (const task of board.tasks) {
+            mdxCache.set(task.id, loadMdxContent(kanbanDir, task));
+        }
+    }
+    const q = query.trim();
+    // Filter + match in one pass
+    const matched = [];
+    for (const task of board.tasks) {
+        // archived filter
+        if (!archived && task.archived)
+            continue;
+        // column filter
+        if (column && task.column !== column)
+            continue;
+        // priority filter
+        if (priority && priority !== "all" && task.priority !== priority)
+            continue;
+        // category filter
+        if (category && category !== "all" && task.category !== category)
+            continue;
+        // assignee filter (case-insensitive)
+        if (assignee) {
+            const found = task.assignees?.some(a => matches(a, assignee)) ?? false;
+            if (!found)
+                continue;
+        }
+        // AND tags filter
+        if (tags && tags.length > 0) {
+            const taskTagsLower = (task.tags ?? []).map(t => t.toLowerCase());
+            const allMatch = tags.every(tag => taskTagsLower.some(t => matches(t, tag)));
+            if (!allMatch)
+                continue;
+        }
+        // text query
+        if (q) {
+            const mdxContent = mdxCache.get(task.id) ?? "";
+            const matchIn = findMatchIn(task, q, mdxContent);
+            if (matchIn.length === 0)
+                continue;
+            matched.push({ ...task, matchIn });
+        }
+        else {
+            // no query — return everything passing filters with empty matchIn
+            matched.push({ ...task, matchIn: [] });
+        }
+    }
+    // Sort: active tasks first by column order, then archived
+    const colOrder = Object.fromEntries(board.columns.map((c, i) => [c.id, i]));
+    matched.sort((a, b) => {
+        if (a.archived !== b.archived)
+            return a.archived ? 1 : -1;
+        const ca = colOrder[a.column] ?? 99;
+        const cb = colOrder[b.column] ?? 99;
+        if (ca !== cb)
+            return ca - cb;
+        return a.order - b.order;
+    });
+    const total = matched.length;
+    const paginated = matched.slice(offset, offset + limit);
+    return { results: paginated, total };
+}