claude-code-workflow 6.3.16 → 6.3.18

package/ccw/src/utils/python-utils.ts

@@ -0,0 +1,121 @@
+/**
+ * Python detection and version compatibility utilities
+ * Shared module for consistent Python discovery across the application
+ */
+
+import { execSync } from 'child_process';
+
+/**
+ * Parse Python version string to major.minor numbers
+ * @param versionStr - Version string like "Python 3.11.5"
+ * @returns Object with major and minor version numbers, or null if parsing fails
+ */
+export function parsePythonVersion(versionStr: string): { major: number; minor: number } | null {
+  const match = versionStr.match(/Python\s+(\d+)\.(\d+)/);
+  if (match) {
+    return { major: parseInt(match[1], 10), minor: parseInt(match[2], 10) };
+  }
+  return null;
+}
+
+/**
+ * Check if Python version is compatible with onnxruntime (3.9-3.12)
+ * @param major - Major version number
+ * @param minor - Minor version number
+ * @returns true if compatible
+ */
+export function isPythonVersionCompatible(major: number, minor: number): boolean {
+  // onnxruntime currently supports Python 3.9-3.12
+  return major === 3 && minor >= 9 && minor <= 12;
+}
+
+/**
+ * Detect available Python 3 executable
+ * Supports CCW_PYTHON environment variable for custom Python path
+ * On Windows, uses py launcher to find compatible versions
+ * @returns Python executable command
+ */
+export function getSystemPython(): string {
+  // Check for user-specified Python via environment variable
+  const customPython = process.env.CCW_PYTHON;
+  if (customPython) {
+    try {
+      const version = execSync(`"${customPython}" --version 2>&1`, { encoding: 'utf8' });
+      if (version.includes('Python 3')) {
+        const parsed = parsePythonVersion(version);
+        if (parsed && !isPythonVersionCompatible(parsed.major, parsed.minor)) {
+          console.warn(`[Python] Warning: CCW_PYTHON points to Python ${parsed.major}.${parsed.minor}, which may not be compatible with onnxruntime (requires 3.9-3.12)`);
+        }
+        return `"${customPython}"`;
+      }
+    } catch {
+      console.warn(`[Python] Warning: CCW_PYTHON="${customPython}" is not a valid Python executable, falling back to system Python`);
+    }
+  }
+
+  // On Windows, try py launcher with specific versions first (3.12, 3.11, 3.10, 3.9)
+  if (process.platform === 'win32') {
+    const compatibleVersions = ['3.12', '3.11', '3.10', '3.9'];
+    for (const ver of compatibleVersions) {
+      try {
+        const version = execSync(`py -${ver} --version 2>&1`, { encoding: 'utf8' });
+        if (version.includes(`Python ${ver}`)) {
+          console.log(`[Python] Found compatible Python ${ver} via py launcher`);
+          return `py -${ver}`;
+        }
+      } catch {
+        // Version not installed, try next
+      }
+    }
+  }
+
+  const commands = process.platform === 'win32' ? ['python', 'py', 'python3'] : ['python3', 'python'];
+  let fallbackCmd: string | null = null;
+  let fallbackVersion: { major: number; minor: number } | null = null;
+
+  for (const cmd of commands) {
+    try {
+      const version = execSync(`${cmd} --version 2>&1`, { encoding: 'utf8' });
+      if (version.includes('Python 3')) {
+        const parsed = parsePythonVersion(version);
+        if (parsed) {
+          // Prefer compatible version (3.9-3.12)
+          if (isPythonVersionCompatible(parsed.major, parsed.minor)) {
+            return cmd;
+          }
+          // Keep track of first Python 3 found as fallback
+          if (!fallbackCmd) {
+            fallbackCmd = cmd;
+            fallbackVersion = parsed;
+          }
+        }
+      }
+    } catch {
+      // Try next command
+    }
+  }
+
+  // If no compatible version found, use fallback with warning
+  if (fallbackCmd && fallbackVersion) {
+    console.warn(`[Python] Warning: Only Python ${fallbackVersion.major}.${fallbackVersion.minor} found, which may not be compatible with onnxruntime (requires 3.9-3.12).`);
+    console.warn('[Python] To use a specific Python version, set CCW_PYTHON environment variable:');
+    console.warn('  Windows: set CCW_PYTHON=C:\\path\\to\\python.exe');
+    console.warn('  Unix: export CCW_PYTHON=/path/to/python3.11');
+    console.warn('[Python] Alternatively, use LiteLLM embedding backend which has no Python version restrictions.');
+    return fallbackCmd;
+  }
+
+  throw new Error('Python 3 not found. Please install Python 3.9-3.12 and ensure it is in PATH, or set CCW_PYTHON environment variable.');
+}
+
+/**
+ * Get the Python command for pip operations (uses -m pip for reliability)
+ * @returns Array of command arguments for spawn
+ */
+export function getPipCommand(): { pythonCmd: string; pipArgs: string[] } {
+  const pythonCmd = getSystemPython();
+  return {
+    pythonCmd,
+    pipArgs: ['-m', 'pip']
+  };
+}

package/codex-lens/src/codexlens/search/enrichment.py

@@ -1,150 +1,150 @@
-# codex-lens/src/codexlens/search/enrichment.py
-"""Relationship enrichment for search results."""
-import sqlite3
-from pathlib import Path
-from typing import List, Dict, Any, Optional
-
-
-class RelationshipEnricher:
-    """Enriches search results with code graph relationships."""
-
-    def __init__(self, index_path: Path):
-        """Initialize with path to index database.
-
-        Args:
-            index_path: Path to _index.db SQLite database
-        """
-        self.index_path = index_path
-        self.db_conn: Optional[sqlite3.Connection] = None
-        self._connect()
-
-    def _connect(self) -> None:
-        """Establish read-only database connection."""
-        if self.index_path.exists():
-            self.db_conn = sqlite3.connect(
-                f"file:{self.index_path}?mode=ro",
-                uri=True,
-                check_same_thread=False
-            )
-            self.db_conn.row_factory = sqlite3.Row
-
-    def enrich(self, results: List[Dict[str, Any]], limit: int = 10) -> List[Dict[str, Any]]:
-        """Add relationship data to search results.
-
-        Args:
-            results: List of search result dictionaries
-            limit: Maximum number of results to enrich
-
-        Returns:
-            Results with relationships field added
-        """
-        if not self.db_conn:
-            return results
-
-        for result in results[:limit]:
-            file_path = result.get('file') or result.get('path')
-            symbol_name = result.get('symbol')
-            result['relationships'] = self._find_relationships(file_path, symbol_name)
-        return results
-
-    def _find_relationships(self, file_path: Optional[str], symbol_name: Optional[str]) -> List[Dict[str, Any]]:
-        """Query relationships for a symbol.
-
-        Args:
-            file_path: Path to file containing the symbol
-            symbol_name: Name of the symbol
-
-        Returns:
-            List of relationship dictionaries with type, direction, target/source, file, line
-        """
-        if not self.db_conn or not symbol_name:
-            return []
-
-        relationships = []
-        cursor = self.db_conn.cursor()
-
-        try:
-            # Find symbol ID(s) by name and optionally file
-            if file_path:
-                cursor.execute(
-                    'SELECT id FROM symbols WHERE name = ? AND file_path = ?',
-                    (symbol_name, file_path)
-                )
-            else:
-                cursor.execute('SELECT id FROM symbols WHERE name = ?', (symbol_name,))
-
-            symbol_ids = [row[0] for row in cursor.fetchall()]
-
-            if not symbol_ids:
-                return []
-
-            # Query outgoing relationships (symbol is source)
-            placeholders = ','.join('?' * len(symbol_ids))
-            cursor.execute(f'''
-                SELECT sr.relationship_type, sr.target_symbol_fqn, sr.file_path, sr.line
-                FROM symbol_relationships sr
-                WHERE sr.source_symbol_id IN ({placeholders})
-            ''', symbol_ids)
-
-            for row in cursor.fetchall():
-                relationships.append({
-                    'type': row[0],
-                    'direction': 'outgoing',
-                    'target': row[1],
-                    'file': row[2],
-                    'line': row[3],
-                })
-
-            # Query incoming relationships (symbol is target)
-            # Match against symbol name or qualified name patterns
-            cursor.execute('''
-                SELECT sr.relationship_type, s.name AS source_name, sr.file_path, sr.line
-                FROM symbol_relationships sr
-                JOIN symbols s ON sr.source_symbol_id = s.id
-                WHERE sr.target_symbol_fqn = ? OR sr.target_symbol_fqn LIKE ?
-            ''', (symbol_name, f'%.{symbol_name}'))
-
-            for row in cursor.fetchall():
-                rel_type = row[0]
-                # Convert to incoming type
-                incoming_type = self._to_incoming_type(rel_type)
-                relationships.append({
-                    'type': incoming_type,
-                    'direction': 'incoming',
-                    'source': row[1],
-                    'file': row[2],
-                    'line': row[3],
-                })
-
-        except sqlite3.Error:
-            return []
-
-        return relationships
-
-    def _to_incoming_type(self, outgoing_type: str) -> str:
-        """Convert outgoing relationship type to incoming type.
-
-        Args:
-            outgoing_type: The outgoing relationship type (e.g., 'calls', 'imports')
-
-        Returns:
-            Corresponding incoming type (e.g., 'called_by', 'imported_by')
-        """
-        type_map = {
-            'calls': 'called_by',
-            'imports': 'imported_by',
-            'extends': 'extended_by',
-        }
-        return type_map.get(outgoing_type, f'{outgoing_type}_by')
-
-    def close(self) -> None:
-        """Close database connection."""
-        if self.db_conn:
-            self.db_conn.close()
-            self.db_conn = None
-
-    def __enter__(self) -> 'RelationshipEnricher':
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        self.close()
+# codex-lens/src/codexlens/search/enrichment.py
+"""Relationship enrichment for search results."""
+import sqlite3
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+
+class RelationshipEnricher:
+    """Enriches search results with code graph relationships."""
+
+    def __init__(self, index_path: Path):
+        """Initialize with path to index database.
+
+        Args:
+            index_path: Path to _index.db SQLite database
+        """
+        self.index_path = index_path
+        self.db_conn: Optional[sqlite3.Connection] = None
+        self._connect()
+
+    def _connect(self) -> None:
+        """Establish read-only database connection."""
+        if self.index_path.exists():
+            self.db_conn = sqlite3.connect(
+                f"file:{self.index_path}?mode=ro",
+                uri=True,
+                check_same_thread=False
+            )
+            self.db_conn.row_factory = sqlite3.Row
+
+    def enrich(self, results: List[Dict[str, Any]], limit: int = 10) -> List[Dict[str, Any]]:
+        """Add relationship data to search results.
+
+        Args:
+            results: List of search result dictionaries
+            limit: Maximum number of results to enrich
+
+        Returns:
+            Results with relationships field added
+        """
+        if not self.db_conn:
+            return results
+
+        for result in results[:limit]:
+            file_path = result.get('file') or result.get('path')
+            symbol_name = result.get('symbol')
+            result['relationships'] = self._find_relationships(file_path, symbol_name)
+        return results
+
+    def _find_relationships(self, file_path: Optional[str], symbol_name: Optional[str]) -> List[Dict[str, Any]]:
+        """Query relationships for a symbol.
+
+        Args:
+            file_path: Path to file containing the symbol
+            symbol_name: Name of the symbol
+
+        Returns:
+            List of relationship dictionaries with type, direction, target/source, file, line
+        """
+        if not self.db_conn or not symbol_name:
+            return []
+
+        relationships = []
+        cursor = self.db_conn.cursor()
+
+        try:
+            # Find symbol ID(s) by name and optionally file
+            if file_path:
+                cursor.execute(
+                    'SELECT id FROM symbols WHERE name = ? AND file_path = ?',
+                    (symbol_name, file_path)
+                )
+            else:
+                cursor.execute('SELECT id FROM symbols WHERE name = ?', (symbol_name,))
+
+            symbol_ids = [row[0] for row in cursor.fetchall()]
+
+            if not symbol_ids:
+                return []
+
+            # Query outgoing relationships (symbol is source)
+            placeholders = ','.join('?' * len(symbol_ids))
+            cursor.execute(f'''
+                SELECT sr.relationship_type, sr.target_symbol_fqn, sr.file_path, sr.line
+                FROM symbol_relationships sr
+                WHERE sr.source_symbol_id IN ({placeholders})
+            ''', symbol_ids)
+
+            for row in cursor.fetchall():
+                relationships.append({
+                    'type': row[0],
+                    'direction': 'outgoing',
+                    'target': row[1],
+                    'file': row[2],
+                    'line': row[3],
+                })
+
+            # Query incoming relationships (symbol is target)
+            # Match against symbol name or qualified name patterns
+            cursor.execute('''
+                SELECT sr.relationship_type, s.name AS source_name, sr.file_path, sr.line
+                FROM symbol_relationships sr
+                JOIN symbols s ON sr.source_symbol_id = s.id
+                WHERE sr.target_symbol_fqn = ? OR sr.target_symbol_fqn LIKE ?
+            ''', (symbol_name, f'%.{symbol_name}'))
+
+            for row in cursor.fetchall():
+                rel_type = row[0]
+                # Convert to incoming type
+                incoming_type = self._to_incoming_type(rel_type)
+                relationships.append({
+                    'type': incoming_type,
+                    'direction': 'incoming',
+                    'source': row[1],
+                    'file': row[2],
+                    'line': row[3],
+                })
+
+        except sqlite3.Error:
+            return []
+
+        return relationships
+
+    def _to_incoming_type(self, outgoing_type: str) -> str:
+        """Convert outgoing relationship type to incoming type.
+
+        Args:
+            outgoing_type: The outgoing relationship type (e.g., 'calls', 'imports')
+
+        Returns:
+            Corresponding incoming type (e.g., 'called_by', 'imported_by')
+        """
+        type_map = {
+            'calls': 'called_by',
+            'imports': 'imported_by',
+            'extends': 'extended_by',
+        }
+        return type_map.get(outgoing_type, f'{outgoing_type}_by')
+
+    def close(self) -> None:
+        """Close database connection."""
+        if self.db_conn:
+            self.db_conn.close()
+            self.db_conn = None
+
+    def __enter__(self) -> 'RelationshipEnricher':
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-workflow",
-  "version": "6.3.16",
+  "version": "6.3.18",
   "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",