claude-code-workflow 6.1.4 → 6.2.1

package/src/core/manifest.ts

@@ -0,0 +1,271 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Manifest directory location
+const MANIFEST_DIR = join(homedir(), '.claude-manifests');
+
+export interface ManifestFileEntry {
+  path: string;
+  type: 'File';
+  timestamp: string;
+}
+
+export interface ManifestDirectoryEntry {
+  path: string;
+  type: 'Directory';
+  timestamp: string;
+}
+
+export interface Manifest {
+  manifest_id: string;
+  version: string;
+  installation_mode: string;
+  installation_path: string;
+  installation_date: string;
+  installer_version: string;
+  files: ManifestFileEntry[];
+  directories: ManifestDirectoryEntry[];
+}
+
+export interface ManifestWithMetadata extends Manifest {
+  manifest_file: string;
+  application_version: string;
+  files_count: number;
+  directories_count: number;
+}
+
+/**
+ * Ensure manifest directory exists
+ */
+function ensureManifestDir(): void {
+  if (!existsSync(MANIFEST_DIR)) {
+    mkdirSync(MANIFEST_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Create a new installation manifest
+ * @param mode - Installation mode (Global/Path)
+ * @param installPath - Installation path
+ * @returns New manifest object
+ */
+export function createManifest(mode: string, installPath: string): Manifest {
+  ensureManifestDir();
+
+  const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace('T', '-').split('.')[0];
+  const modePrefix = mode === 'Global' ? 'manifest-global' : 'manifest-path';
+  const manifestId = `${modePrefix}-${timestamp}`;
+
+  return {
+    manifest_id: manifestId,
+    version: '1.0',
+    installation_mode: mode,
+    installation_path: installPath,
+    installation_date: new Date().toISOString(),
+    installer_version: '1.0.0',
+    files: [],
+    directories: []
+  };
+}
+
+/**
+ * Add file entry to manifest
+ * @param manifest - Manifest object
+ * @param filePath - File path
+ */
+export function addFileEntry(manifest: Manifest, filePath: string): void {
+  manifest.files.push({
+    path: filePath,
+    type: 'File',
+    timestamp: new Date().toISOString()
+  });
+}
+
+/**
+ * Add directory entry to manifest
+ * @param manifest - Manifest object
+ * @param dirPath - Directory path
+ */
+export function addDirectoryEntry(manifest: Manifest, dirPath: string): void {
+  manifest.directories.push({
+    path: dirPath,
+    type: 'Directory',
+    timestamp: new Date().toISOString()
+  });
+}
+
+/**
+ * Save manifest to disk
+ * @param manifest - Manifest object
+ * @returns Path to saved manifest
+ */
+export function saveManifest(manifest: Manifest): string {
+  ensureManifestDir();
+
+  // Remove old manifests for same path and mode
+  removeOldManifests(manifest.installation_path, manifest.installation_mode);
+
+  const manifestPath = join(MANIFEST_DIR, `${manifest.manifest_id}.json`);
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+
+  return manifestPath;
+}
+
+/**
+ * Remove old manifests for the same installation path and mode
+ * @param installPath - Installation path
+ * @param mode - Installation mode
+ */
+function removeOldManifests(installPath: string, mode: string): void {
+  if (!existsSync(MANIFEST_DIR)) return;
+
+  const normalizedPath = installPath.toLowerCase().replace(/[\\/]+$/, '');
+
+  try {
+    const files = readdirSync(MANIFEST_DIR).filter(f => f.endsWith('.json'));
+
+    for (const file of files) {
+      try {
+        const filePath = join(MANIFEST_DIR, file);
+        const content = JSON.parse(readFileSync(filePath, 'utf8')) as Partial<Manifest>;
+
+        const manifestPath = (content.installation_path || '').toLowerCase().replace(/[\\/]+$/, '');
+        const manifestMode = content.installation_mode || 'Global';
+
+        if (manifestPath === normalizedPath && manifestMode === mode) {
+          unlinkSync(filePath);
+        }
+      } catch {
+        // Skip invalid manifest files
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Get all installation manifests
+ * @returns Array of manifest objects
+ */
+export function getAllManifests(): ManifestWithMetadata[] {
+  if (!existsSync(MANIFEST_DIR)) return [];
+
+  const manifests: ManifestWithMetadata[] = [];
+
+  try {
+    const files = readdirSync(MANIFEST_DIR).filter(f => f.endsWith('.json'));
+
+    for (const file of files) {
+      try {
+        const filePath = join(MANIFEST_DIR, file);
+        const content = JSON.parse(readFileSync(filePath, 'utf8')) as Manifest;
+
+        // Try to read version.json for application version
+        let appVersion = 'unknown';
+        try {
+          const versionPath = join(content.installation_path, '.claude', 'version.json');
+          if (existsSync(versionPath)) {
+            const versionInfo = JSON.parse(readFileSync(versionPath, 'utf8')) as { version?: string };
+            appVersion = versionInfo.version || 'unknown';
+          }
+        } catch {
+          // Ignore
+        }
+
+        manifests.push({
+          ...content,
+          manifest_file: filePath,
+          application_version: appVersion,
+          files_count: content.files?.length || 0,
+          directories_count: content.directories?.length || 0
+        });
+      } catch {
+        // Skip invalid manifest files
+      }
+    }
+
+    // Sort by installation date (newest first)
+    manifests.sort((a, b) => new Date(b.installation_date).getTime() - new Date(a.installation_date).getTime());
+
+  } catch {
+    // Ignore errors
+  }
+
+  return manifests;
+}
+
+/**
+ * Find manifest for a specific path and mode
+ * @param installPath - Installation path
+ * @param mode - Installation mode
+ * @returns Manifest or null
+ */
+export function findManifest(installPath: string, mode: string): ManifestWithMetadata | null {
+  const manifests = getAllManifests();
+  const normalizedPath = installPath.toLowerCase().replace(/[\\/]+$/, '');
+
+  return manifests.find(m => {
+    const manifestPath = (m.installation_path || '').toLowerCase().replace(/[\\/]+$/, '');
+    return manifestPath === normalizedPath && m.installation_mode === mode;
+  }) || null;
+}
+
+/**
+ * Delete a manifest file
+ * @param manifestFile - Path to manifest file
+ */
+export function deleteManifest(manifestFile: string): void {
+  if (existsSync(manifestFile)) {
+    unlinkSync(manifestFile);
+  }
+}
+
+/**
+ * Get manifest directory path
+ * @returns Manifest directory path
+ */
+export function getManifestDir(): string {
+  return MANIFEST_DIR;
+}
+
+/**
+ * Get file reference counts across all manifests
+ * Returns a map of file path -> array of manifest IDs that reference it
+ * @param excludeManifestId - Optional manifest ID to exclude from counting
+ * @returns Map of file paths to referencing manifest IDs
+ */
+export function getFileReferenceCounts(excludeManifestId?: string): Map<string, string[]> {
+  const fileRefs = new Map<string, string[]>();
+  const manifests = getAllManifests();
+
+  for (const manifest of manifests) {
+    // Skip the excluded manifest (usually the one being replaced)
+    if (excludeManifestId && manifest.manifest_id === excludeManifestId) {
+      continue;
+    }
+
+    for (const fileEntry of manifest.files || []) {
+      const normalizedPath = fileEntry.path.toLowerCase().replace(/\\/g, '/');
+      const refs = fileRefs.get(normalizedPath) || [];
+      refs.push(manifest.manifest_id);
+      fileRefs.set(normalizedPath, refs);
+    }
+  }
+
+  return fileRefs;
+}
+
+/**
+ * Check if a file is referenced by other installations
+ * @param filePath - File path to check
+ * @param excludeManifestId - Manifest ID to exclude from checking
+ * @returns True if file is referenced by other installations
+ */
+export function isFileReferencedByOthers(filePath: string, excludeManifestId: string): boolean {
+  const fileRefs = getFileReferenceCounts(excludeManifestId);
+  const normalizedPath = filePath.toLowerCase().replace(/\\/g, '/');
+  const refs = fileRefs.get(normalizedPath) || [];
+  return refs.length > 0;
+}

package/src/core/memory-embedder-bridge.ts

@@ -0,0 +1,262 @@
+/**
+ * Memory Embedder Bridge - TypeScript interface to Python memory embedder
+ *
+ * This module provides a TypeScript bridge to the Python memory_embedder.py script,
+ * which generates and searches embeddings for memory chunks using CodexLens's embedder.
+ *
+ * Features:
+ * - Reuses CodexLens venv at ~/.codexlens/venv
+ * - JSON protocol communication
+ * - Three commands: embed, search, status
+ * - Automatic availability checking
+ */
+
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+
+// Get directory of this module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Venv paths (reuse CodexLens venv)
+const CODEXLENS_VENV = join(homedir(), '.codexlens', 'venv');
+const VENV_PYTHON =
+  process.platform === 'win32'
+    ? join(CODEXLENS_VENV, 'Scripts', 'python.exe')
+    : join(CODEXLENS_VENV, 'bin', 'python');
+
+// Script path
+const EMBEDDER_SCRIPT = join(__dirname, '..', '..', 'scripts', 'memory_embedder.py');
+
+// Types
+export interface EmbedResult {
+  success: boolean;
+  chunks_processed: number;
+  chunks_failed: number;
+  elapsed_time: number;
+  error?: string;
+}
+
+export interface SearchMatch {
+  source_id: string;
+  source_type: 'core_memory' | 'workflow' | 'cli_history';
+  chunk_index: number;
+  content: string;
+  score: number;
+  restore_command: string;
+}
+
+export interface SearchResult {
+  success: boolean;
+  matches: SearchMatch[];
+  query?: string;
+  elapsed_time?: number;
+  error?: string;
+}
+
+export interface EmbeddingStatus {
+  success?: boolean;
+  total_chunks: number;
+  embedded_chunks: number;
+  pending_chunks: number;
+  by_type: Record<string, { total: number; embedded: number; pending: number }>;
+  error?: string;
+}
+
+export interface EmbedOptions {
+  sourceId?: string;
+  batchSize?: number;
+  force?: boolean;
+}
+
+export interface SearchOptions {
+  topK?: number;
+  minScore?: number;
+  sourceType?: 'core_memory' | 'workflow' | 'cli_history';
+}
+
+/**
+ * Check if embedder is available (venv and script exist)
+ * @returns True if embedder is available
+ */
+export function isEmbedderAvailable(): boolean {
+  // Check venv python exists
+  if (!existsSync(VENV_PYTHON)) {
+    return false;
+  }
+
+  // Check script exists
+  if (!existsSync(EMBEDDER_SCRIPT)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Run Python script with arguments
+ * @param args - Command line arguments
+ * @param timeout - Timeout in milliseconds
+ * @returns JSON output from script
+ */
+function runPython(args: string[], timeout: number = 300000): Promise<string> {
+  return new Promise((resolve, reject) => {
+    // Check availability
+    if (!isEmbedderAvailable()) {
+      reject(
+        new Error(
+          'Memory embedder not available. Ensure CodexLens venv exists at ~/.codexlens/venv'
+        )
+      );
+      return;
+    }
+
+    // Spawn Python process
+    const child = spawn(VENV_PYTHON, [EMBEDDER_SCRIPT, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(`Python script failed (exit code ${code}): ${stderr || stdout}`));
+      }
+    });
+
+    child.on('error', (err) => {
+      if ((err as NodeJS.ErrnoException).code === 'ETIMEDOUT') {
+        reject(new Error('Python script timed out'));
+      } else {
+        reject(new Error(`Failed to spawn Python: ${err.message}`));
+      }
+    });
+  });
+}
+
+/**
+ * Generate embeddings for memory chunks
+ * @param dbPath - Path to SQLite database
+ * @param options - Embedding options
+ * @returns Embedding result
+ */
+export async function generateEmbeddings(
+  dbPath: string,
+  options: EmbedOptions = {}
+): Promise<EmbedResult> {
+  const { sourceId, batchSize = 8, force = false } = options;
+
+  // Build arguments
+  const args = ['embed', dbPath];
+
+  if (sourceId) {
+    args.push('--source-id', sourceId);
+  }
+
+  if (batchSize !== 8) {
+    args.push('--batch-size', batchSize.toString());
+  }
+
+  if (force) {
+    args.push('--force');
+  }
+
+  try {
+    // Default timeout: 5 minutes
+    const output = await runPython(args, 300000);
+    const result = JSON.parse(output) as EmbedResult;
+    return result;
+  } catch (err) {
+    return {
+      success: false,
+      chunks_processed: 0,
+      chunks_failed: 0,
+      elapsed_time: 0,
+      error: (err as Error).message,
+    };
+  }
+}
+
+/**
+ * Search memory chunks using semantic search
+ * @param dbPath - Path to SQLite database
+ * @param query - Search query text
+ * @param options - Search options
+ * @returns Search results
+ */
+export async function searchMemories(
+  dbPath: string,
+  query: string,
+  options: SearchOptions = {}
+): Promise<SearchResult> {
+  const { topK = 10, minScore = 0.3, sourceType } = options;
+
+  // Build arguments
+  const args = ['search', dbPath, query];
+
+  if (topK !== 10) {
+    args.push('--top-k', topK.toString());
+  }
+
+  if (minScore !== 0.3) {
+    args.push('--min-score', minScore.toString());
+  }
+
+  if (sourceType) {
+    args.push('--type', sourceType);
+  }
+
+  try {
+    // Default timeout: 30 seconds
+    const output = await runPython(args, 30000);
+    const result = JSON.parse(output) as SearchResult;
+    return result;
+  } catch (err) {
+    return {
+      success: false,
+      matches: [],
+      error: (err as Error).message,
+    };
+  }
+}
+
+/**
+ * Get embedding status statistics
+ * @param dbPath - Path to SQLite database
+ * @returns Embedding status
+ */
+export async function getEmbeddingStatus(dbPath: string): Promise<EmbeddingStatus> {
+  // Build arguments
+  const args = ['status', dbPath];
+
+  try {
+    // Default timeout: 30 seconds
+    const output = await runPython(args, 30000);
+    const result = JSON.parse(output) as EmbeddingStatus;
+    return { ...result, success: true };
+  } catch (err) {
+    return {
+      success: false,
+      total_chunks: 0,
+      embedded_chunks: 0,
+      pending_chunks: 0,
+      by_type: {},
+      error: (err as Error).message,
+    };
+  }
+}