claude-code-workflow 6.3.13 → 6.3.15

package/codex-lens/src/codexlens/storage/sqlite_store.py

@@ -2,55 +2,68 @@
 
 from __future__ import annotations
 
-import json
-import sqlite3
-import threading
-import time
-from dataclasses import asdict
-from pathlib import Path
+import json
+import logging
+import sqlite3
+import threading
+import time
+from dataclasses import asdict
+from pathlib import Path
 from typing import Any, Dict, Iterable, List, Optional, Tuple
 
-from codexlens.entities import IndexedFile, SearchResult, Symbol
-from codexlens.errors import StorageError
-
-
-class SQLiteStore:
-    """SQLiteStore providing FTS5 search and symbol lookup.
-
-    Implements thread-local connection pooling for improved performance.
-    """
-
-    # Maximum number of connections to keep in pool to prevent memory leaks
-    MAX_POOL_SIZE = 32
-    # Idle timeout in seconds (10 minutes)
-    IDLE_TIMEOUT = 600
-
-    def __init__(self, db_path: str | Path) -> None:
-        self.db_path = Path(db_path)
-        self._lock = threading.RLock()
-        self._local = threading.local()
-        self._pool_lock = threading.Lock()
-        # Pool stores (connection, last_access_time) tuples
-        self._pool: Dict[int, Tuple[sqlite3.Connection, float]] = {}
-        self._pool_generation = 0
+from codexlens.entities import IndexedFile, SearchResult, Symbol
+from codexlens.errors import StorageError
+
+logger = logging.getLogger(__name__)
+
+
+class SQLiteStore:
+    """SQLiteStore providing FTS5 search and symbol lookup.
+
+    Implements thread-local connection pooling for improved performance.
+    """
+
+    # Maximum number of connections to keep in pool to prevent memory leaks
+    MAX_POOL_SIZE = 32
+    # Idle timeout in seconds (10 minutes)
+    IDLE_TIMEOUT = 600
+    # Periodic cleanup interval in seconds (5 minutes)
+    CLEANUP_INTERVAL = 300
+
+    def __init__(self, db_path: str | Path) -> None:
+        self.db_path = Path(db_path)
+        self._lock = threading.RLock()
+        self._local = threading.local()
+        self._pool_lock = threading.Lock()
+        # Pool stores (connection, last_access_time) tuples
+        self._pool: Dict[int, Tuple[sqlite3.Connection, float]] = {}
+        self._pool_generation = 0
+        self._cleanup_timer: threading.Timer | None = None
+        self._cleanup_stop_event = threading.Event()
+        self._start_cleanup_timer()
 
     def _get_connection(self) -> sqlite3.Connection:
         """Get or create a thread-local database connection."""
         thread_id = threading.get_ident()
         current_time = time.time()
 
-        if getattr(self._local, "generation", None) == self._pool_generation:
-            conn = getattr(self._local, "conn", None)
-            if conn is not None:
-                # Update last access time
-                with self._pool_lock:
-                    if thread_id in self._pool:
-                        self._pool[thread_id] = (conn, current_time)
-                return conn
-
-        with self._pool_lock:
-            pool_entry = self._pool.get(thread_id)
-            if pool_entry is not None:
+        if getattr(self._local, "generation", None) == self._pool_generation:
+            conn = getattr(self._local, "conn", None)
+            if conn is not None:
+                with self._pool_lock:
+                    pool_entry = self._pool.get(thread_id)
+                    if pool_entry is not None:
+                        pooled_conn, _ = pool_entry
+                        self._pool[thread_id] = (pooled_conn, current_time)
+                        self._local.conn = pooled_conn
+                        return pooled_conn
+
+                # Thread-local connection is stale (e.g., cleaned up by timer).
+                self._local.conn = None
+
+        with self._pool_lock:
+            pool_entry = self._pool.get(thread_id)
+            if pool_entry is not None:
                 conn, _ = pool_entry
                 # Update last access time
                 self._pool[thread_id] = (conn, current_time)
@@ -72,37 +85,91 @@ class SQLiteStore:
             self._local.generation = self._pool_generation
             return conn
 
-    def _cleanup_stale_connections(self) -> None:
-        """Remove connections for threads that no longer exist or have been idle too long."""
-        current_time = time.time()
-        # Get list of active thread IDs
-        active_threads = {t.ident for t in threading.enumerate() if t.ident is not None}
-
-        # Find connections to remove: dead threads or idle timeout exceeded
-        stale_ids = []
-        for tid, (conn, last_access) in list(self._pool.items()):
-            is_dead_thread = tid not in active_threads
-            is_idle = (current_time - last_access) > self.IDLE_TIMEOUT
-            if is_dead_thread or is_idle:
-                stale_ids.append(tid)
-
-        # Close and remove stale connections
-        for tid in stale_ids:
-            try:
-                conn, _ = self._pool[tid]
-                conn.close()
-            except Exception:
-                pass
-            del self._pool[tid]
-
-    def close(self) -> None:
-        """Close all pooled connections."""
-        with self._lock:
-            with self._pool_lock:
-                for conn, _ in self._pool.values():
-                    conn.close()
-                self._pool.clear()
-                self._pool_generation += 1
+    def _cleanup_stale_connections(self) -> None:
+        """Remove connections for threads that no longer exist or have been idle too long."""
+        current_time = time.time()
+        # Get list of active thread IDs
+        active_threads = {t.ident for t in threading.enumerate() if t.ident is not None}
+
+        # Find connections to remove: dead threads or idle timeout exceeded
+        stale_ids: list[tuple[int, str]] = []
+        for tid, (conn, last_access) in list(self._pool.items()):
+            try:
+                is_dead_thread = tid not in active_threads
+                is_idle = (current_time - last_access) > self.IDLE_TIMEOUT
+
+                is_invalid_connection = False
+                if not is_dead_thread and not is_idle:
+                    try:
+                        conn.execute("SELECT 1").fetchone()
+                    except sqlite3.ProgrammingError:
+                        is_invalid_connection = True
+                    except sqlite3.Error:
+                        is_invalid_connection = True
+
+                if is_invalid_connection:
+                    stale_ids.append((tid, "invalid_connection"))
+                elif is_dead_thread:
+                    stale_ids.append((tid, "dead_thread"))
+                elif is_idle:
+                    stale_ids.append((tid, "idle_timeout"))
+            except Exception:
+                # Never break cleanup for a single bad entry.
+                continue
+
+        # Close and remove stale connections
+        for tid, reason in stale_ids:
+            try:
+                conn, _ = self._pool[tid]
+                conn.close()
+            except Exception:
+                pass
+            del self._pool[tid]
+            logger.debug("Cleaned SQLiteStore connection for thread_id=%s (%s)", tid, reason)
+
+    def _start_cleanup_timer(self) -> None:
+        if self.CLEANUP_INTERVAL <= 0:
+            return
+
+        self._cleanup_stop_event.clear()
+
+        def tick() -> None:
+            if self._cleanup_stop_event.is_set():
+                return
+
+            try:
+                with self._pool_lock:
+                    self._cleanup_stale_connections()
+            finally:
+                with self._pool_lock:
+                    if self._cleanup_stop_event.is_set():
+                        self._cleanup_timer = None
+                        return
+
+                    self._cleanup_timer = threading.Timer(self.CLEANUP_INTERVAL, tick)
+                    self._cleanup_timer.daemon = True
+                    self._cleanup_timer.start()
+
+        self._cleanup_timer = threading.Timer(self.CLEANUP_INTERVAL, tick)
+        self._cleanup_timer.daemon = True
+        self._cleanup_timer.start()
+
+    def _stop_cleanup_timer(self) -> None:
+        self._cleanup_stop_event.set()
+        with self._pool_lock:
+            if self._cleanup_timer is not None:
+                self._cleanup_timer.cancel()
+                self._cleanup_timer = None
+
+    def close(self) -> None:
+        """Close all pooled connections."""
+        with self._lock:
+            self._stop_cleanup_timer()
+            with self._pool_lock:
+                for conn, _ in self._pool.values():
+                    conn.close()
+                self._pool.clear()
+                self._pool_generation += 1
 
             if hasattr(self._local, "conn"):
                 self._local.conn = None
@@ -262,14 +329,20 @@ class SQLiteStore:
                             ],
                         )
                 
-                conn.commit()
-            except Exception:
-                conn.rollback()
-                raise
-
-    def remove_file(self, path: str | Path) -> bool:
-        """Remove a file from the index."""
-        with self._lock:
+                conn.commit()
+            except Exception as exc:
+                try:
+                    conn.rollback()
+                except Exception as rollback_exc:
+                    logger.error(
+                        "Rollback failed after add_files() error (%s): %s", exc, rollback_exc
+                    )
+                    raise exc.with_traceback(exc.__traceback__) from rollback_exc
+                raise
+
+    def remove_file(self, path: str | Path) -> bool:
+        """Remove a file from the index."""
+        with self._lock:
             conn = self._get_connection()
             resolved_path = str(Path(path).resolve())
 
@@ -539,10 +612,10 @@ class SQLiteStore:
             """
         )
 
-    def _migrate_fts_to_external(self, conn: sqlite3.Connection) -> None:
-        """Migrate legacy files_fts (with duplicated content) to external content."""
-        try:
-            conn.execute("BEGIN")
+    def _migrate_fts_to_external(self, conn: sqlite3.Connection) -> None:
+        """Migrate legacy files_fts (with duplicated content) to external content."""
+        try:
+            conn.execute("BEGIN")
             conn.execute("DROP TRIGGER IF EXISTS files_ai")
             conn.execute("DROP TRIGGER IF EXISTS files_ad")
             conn.execute("DROP TRIGGER IF EXISTS files_au")
@@ -550,27 +623,30 @@ class SQLiteStore:
             conn.execute("ALTER TABLE files_fts RENAME TO files_fts_legacy")
             self._create_external_fts(conn)
             conn.execute("INSERT INTO files_fts(files_fts) VALUES('rebuild')")
-            conn.execute("DROP TABLE files_fts_legacy")
-            conn.commit()
-        except sqlite3.DatabaseError:
-            try:
-                conn.rollback()
-            except Exception:
-                pass
-
-            try:
-                conn.execute("DROP TABLE IF EXISTS files_fts")
-            except Exception:
-                pass
-
-            try:
-                conn.execute("ALTER TABLE files_fts_legacy RENAME TO files_fts")
-                conn.commit()
-            except Exception:
-                pass
-            raise
-
-        try:
-            conn.execute("VACUUM")
-        except sqlite3.DatabaseError:
-            pass
+            conn.execute("DROP TABLE files_fts_legacy")
+            conn.commit()
+        except sqlite3.DatabaseError as exc:
+            try:
+                conn.rollback()
+            except Exception as rollback_exc:
+                logger.error(
+                    "Rollback failed during FTS schema migration (%s): %s", exc, rollback_exc
+                )
+                raise exc.with_traceback(exc.__traceback__) from rollback_exc
+
+            try:
+                conn.execute("DROP TABLE IF EXISTS files_fts")
+            except Exception:
+                pass
+
+            try:
+                conn.execute("ALTER TABLE files_fts_legacy RENAME TO files_fts")
+                conn.commit()
+            except Exception:
+                pass
+            raise
+
+        try:
+            conn.execute("VACUUM")
+        except sqlite3.DatabaseError:
+            pass

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-workflow",
-  "version": "6.3.13",
+  "version": "6.3.15",
   "description": "JSON-driven multi-agent development framework with intelligent CLI orchestration (Gemini/Qwen/Codex), context-first architecture, and automated workflow execution",
   "type": "module",
   "main": "ccw/src/index.js",
@@ -12,6 +12,7 @@
     "build": "tsc -p ccw/tsconfig.json",
     "start": "node ccw/bin/ccw.js",
     "test": "node --experimental-strip-types --test ccw/tests/*.test.js",
+    "test:visual": "node --experimental-strip-types --test ccw/tests/visual/**/*.visual.test.ts",
     "prepublishOnly": "npm run build && echo 'Ready to publish @dyw/claude-code-workflow'"
   },
   "keywords": [
@@ -74,10 +75,14 @@
   },
   "homepage": "https://github.com/catlog22/Claude-Code-Workflow#readme",
   "devDependencies": {
+    "@playwright/test": "^1.57.0",
     "@types/better-sqlite3": "^7.6.12",
     "@types/gradient-string": "^1.1.6",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.0.1",
+    "pixelmatch": "^7.1.0",
+    "playwright": "^1.57.0",
+    "pngjs": "^7.0.0",
     "typescript": "^5.9.3"
   }
 }

package/.claude/commands/issue/manage.md

@@ -1,113 +0,0 @@
----
-name: manage
-description: Interactive issue management (CRUD) via ccw cli endpoints with menu-driven interface
-argument-hint: "[issue-id] [--action list|view|edit|delete|bulk]"
-allowed-tools: TodoWrite(*), Bash(*), Read(*), Write(*), AskUserQuestion(*), Task(*)
----
-
-# Issue Manage Command (/issue:manage)
-
-## Overview
-
-Interactive menu-driven interface for issue management using `ccw issue` CLI endpoints:
-- **List**: Browse and filter issues
-- **View**: Detailed issue inspection
-- **Edit**: Modify issue fields
-- **Delete**: Remove issues
-- **Bulk**: Batch operations on multiple issues
-
-## CLI Endpoints Reference
-
-```bash
-# Core endpoints (ccw issue)
-ccw issue list                      # List all issues
-ccw issue list <id> --json          # Get issue details
-ccw issue status <id>               # Detailed status
-ccw issue init <id> --title "..."   # Create issue
-ccw issue task <id> --title "..."   # Add task
-ccw issue bind <id> <solution-id>   # Bind solution
-
-# Queue management
-ccw issue queue                     # List current queue
-ccw issue queue add <id>            # Add to queue
-ccw issue queue list                # Queue history
-ccw issue queue switch <queue-id>   # Switch queue
-ccw issue queue archive             # Archive queue
-ccw issue queue delete <queue-id>   # Delete queue
-ccw issue next                      # Get next task
-ccw issue done <queue-id>           # Mark completed
-ccw issue complete <item-id>        # (legacy alias for done)
-```
-
-## Usage
-
-```bash
-# Interactive mode (menu-driven)
-/issue:manage
-
-# Direct to specific issue
-/issue:manage GH-123
-
-# Direct action
-/issue:manage --action list
-/issue:manage GH-123 --action edit
-```
-
-## Implementation
-
-This command delegates to the `issue-manage` skill for detailed implementation.
-
-### Entry Point
-
-```javascript
-const issueId = parseIssueId(userInput);
-const action = flags.action;
-
-// Show main menu if no action specified
-if (!action) {
-  await showMainMenu(issueId);
-} else {
-  await executeAction(action, issueId);
-}
-```
-
-### Main Menu Flow
-
-1. **Dashboard**: Fetch issues summary via `ccw issue list --json`
-2. **Menu**: Present action options via AskUserQuestion
-3. **Route**: Execute selected action (List/View/Edit/Delete/Bulk)
-4. **Loop**: Return to menu after each action
-
-### Available Actions
-
-| Action | Description | CLI Command |
-|--------|-------------|-------------|
-| List | Browse with filters | `ccw issue list --json` |
-| View | Detail view | `ccw issue status <id> --json` |
-| Edit | Modify fields | Update `issues.jsonl` |
-| Delete | Remove issue | Clean up all related files |
-| Bulk | Batch operations | Multi-select + batch update |
-
-## Data Files
-
-| File | Purpose |
-|------|---------|
-| `.workflow/issues/issues.jsonl` | Issue records |
-| `.workflow/issues/solutions/<id>.jsonl` | Solutions per issue |
-| `.workflow/issues/queue.json` | Execution queue |
-
-## Error Handling
-
-| Error | Resolution |
-|-------|------------|
-| No issues found | Suggest creating with /issue:new |
-| Issue not found | Show available issues, ask for correction |
-| Invalid selection | Show error, re-prompt |
-| Write failure | Check permissions, show error |
-
-## Related Commands
-
-- `/issue:new` - Create structured issue
-- `/issue:plan` - Plan solution for issue
-- `/issue:queue` - Form execution queue
-- `/issue:execute` - Execute queued tasks