@tonycasey/lisa 0.5.13

package/dist/templates/claude/hooks/common/group-id.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const MAX_GROUP_ID_LENGTH = 128;
+// ============================================================================
+// Group ID Functions
+// ============================================================================
+/**
+ * Normalize a path to a valid group ID string.
+ * /Users/tony.casey/Repos/api -> users-tony.casey-repos-api
+ */
+function normalizePathToGroupId(absolutePath) {
+    let normalized = absolutePath
+        .toLowerCase()
+        .replace(/^\//, '') // Remove leading slash
+        .replace(/\//g, '-') // Replace slashes with dashes
+        .replace(/\./g, '_'); // Replace dots with underscores (Graphiti requires alphanumeric, dashes, underscores only)
+    // Truncate if too long (keep the end which is most specific)
+    if (normalized.length > MAX_GROUP_ID_LENGTH) {
+        normalized = normalized.slice(-MAX_GROUP_ID_LENGTH);
+    }
+    return normalized;
+}
+/**
+ * Get the current folder's group ID.
+ */
+function getCurrentGroupId(cwd = process.cwd()) {
+    return normalizePathToGroupId(cwd);
+}
+/**
+ * Get hierarchical group IDs from current folder up to home directory.
+ * Returns array ordered from most specific (current) to least specific (home).
+ *
+ * Example for /Users/tony/Repos/api/src:
+ * ['users-tony-repos-api-src', 'users-tony-repos-api', 'users-tony-repos', 'users-tony']
+ */
+function getHierarchicalGroupIds(cwd = process.cwd()) {
+    const homeDir = os.homedir();
+    const groups = [];
+    let currentPath = path.resolve(cwd);
+    // Walk up the directory tree until we reach home or root
+    while (currentPath.length >= homeDir.length) {
+        groups.push(normalizePathToGroupId(currentPath));
+        // Stop at home directory
+        if (currentPath === homeDir) {
+            break;
+        }
+        const parentPath = path.dirname(currentPath);
+        // Stop if we can't go up anymore (reached root)
+        if (parentPath === currentPath) {
+            break;
+        }
+        currentPath = parentPath;
+    }
+    return groups;
+}
+/**
+ * Detect folder metadata by checking for project markers and file types.
+ */
+function detectFolderMetadata(cwd = process.cwd()) {
+    const groupId = getCurrentGroupId(cwd);
+    const base = { path: cwd, groupId, type: 'unknown' };
+    // Check for Node.js/TypeScript project
+    const packageJsonPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+            // Detect framework
+            let framework;
+            if (deps.next)
+                framework = 'nextjs';
+            else if (deps.react)
+                framework = 'react';
+            else if (deps.express)
+                framework = 'express';
+            else if (deps.fastify)
+                framework = 'fastify';
+            else if (deps.hono)
+                framework = 'hono';
+            else if (deps.vue)
+                framework = 'vue';
+            else if (deps.angular)
+                framework = 'angular';
+            else if (deps.svelte)
+                framework = 'svelte';
+            // Detect if TypeScript
+            const isTypeScript = deps.typescript || fs.existsSync(path.join(cwd, 'tsconfig.json'));
+            return {
+                ...base,
+                type: 'project',
+                projectType: isTypeScript ? 'typescript' : 'javascript',
+                framework,
+                description: pkg.description,
+            };
+        }
+        catch (_err) {
+            // Invalid package.json, continue detection
+        }
+    }
+    // Check for Python project
+    if (fs.existsSync(path.join(cwd, 'pyproject.toml')) || fs.existsSync(path.join(cwd, 'setup.py'))) {
+        let framework;
+        const reqPath = path.join(cwd, 'requirements.txt');
+        if (fs.existsSync(reqPath)) {
+            try {
+                const reqs = fs.readFileSync(reqPath, 'utf8').toLowerCase();
+                if (reqs.includes('fastapi'))
+                    framework = 'fastapi';
+                else if (reqs.includes('django'))
+                    framework = 'django';
+                else if (reqs.includes('flask'))
+                    framework = 'flask';
+            }
+            catch (_err) {
+                // Ignore
+            }
+        }
+        return { ...base, type: 'project', projectType: 'python', framework };
+    }
+    // Check for Rust project
+    if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
+        return { ...base, type: 'project', projectType: 'rust' };
+    }
+    // Check for Go project
+    if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+        return { ...base, type: 'project', projectType: 'go' };
+    }
+    // Check for Java/Kotlin project
+    if (fs.existsSync(path.join(cwd, 'pom.xml')) || fs.existsSync(path.join(cwd, 'build.gradle'))) {
+        return { ...base, type: 'project', projectType: 'java' };
+    }
+    // Check folder contents for type hints
+    try {
+        const files = fs.readdirSync(cwd);
+        const hasDocuments = files.some((f) => /\.(md|txt|doc|docx|rst)$/i.test(f));
+        const hasAssets = files.some((f) => /\.(png|jpg|jpeg|gif|svg|mp4|mp3|pdf|ai|psd)$/i.test(f));
+        if (hasAssets && !hasDocuments) {
+            return { ...base, type: 'assets' };
+        }
+        if (hasDocuments) {
+            return { ...base, type: 'documents' };
+        }
+    }
+    catch (_err) {
+        // Can't read directory
+    }
+    return base;
+}
+/**
+ * Format folder metadata for display.
+ * Returns a string like "TypeScript/React project" or "Python/FastAPI project"
+ */
+function formatFolderMetadata(metadata) {
+    if (metadata.type === 'unknown') {
+        return 'folder';
+    }
+    if (metadata.type === 'documents') {
+        return 'documents';
+    }
+    if (metadata.type === 'assets') {
+        return 'assets';
+    }
+    // Project type
+    const parts = [];
+    if (metadata.projectType) {
+        // Capitalize first letter
+        parts.push(metadata.projectType.charAt(0).toUpperCase() + metadata.projectType.slice(1));
+    }
+    if (metadata.framework) {
+        // Capitalize first letter
+        parts.push(metadata.framework.charAt(0).toUpperCase() + metadata.framework.slice(1));
+    }
+    if (parts.length === 0) {
+        return 'project';
+    }
+    return `${parts.join('/')} project`;
+}
+module.exports = {
+    MAX_GROUP_ID_LENGTH,
+    normalizePathToGroupId,
+    getCurrentGroupId,
+    getHierarchicalGroupIds,
+    detectFolderMetadata,
+    formatFolderMetadata,
+};

package/dist/templates/claude/hooks/common/mcp-client.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { MCP_ENDPOINT, ZEP_API_KEY } = require('../../config');
+const { getCurrentGroupId, getHierarchicalGroupIds } = require('./group-id');
+const CLIENT_INFO = { name: 'claude-hooks', version: '0.1.0' };
+const PROTOCOL_VERSION = '2024-11-05';
+/**
+ * Get headers for MCP requests.
+ * Adds Zep API key authentication when using Zep Cloud endpoint.
+ */
+function getHeaders() {
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json, text/event-stream',
+    };
+    // Add Zep auth header when using Zep Cloud
+    if (ZEP_API_KEY && MCP_ENDPOINT.includes('getzep.com')) {
+        headers['Authorization'] = `Api-Key ${ZEP_API_KEY}`;
+    }
+    return headers;
+}
+let SESSION_ID = null;
+class MCPError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+function extractEventStreamData(text) {
+    const lines = text.split('\n').map((l) => l.trim());
+    const dataLines = lines.filter((l) => l.startsWith('data:')).map((l) => l.replace(/^data:\s*/, ''));
+    if (!dataLines.length)
+        return null;
+    const candidate = dataLines.join('\n');
+    try {
+        return JSON.parse(candidate);
+    }
+    catch (_err) {
+        return null;
+    }
+}
+async function initialize(timeoutMs = 8000) {
+    const body = {
+        jsonrpc: '2.0',
+        id: 'init',
+        method: 'initialize',
+        params: {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: CLIENT_INFO,
+        },
+    };
+    const resp = await fetch(MCP_ENDPOINT, {
+        method: 'POST',
+        headers: getHeaders(),
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const session = resp.headers.get('mcp-session-id');
+    if (!session)
+        throw new MCPError('No mcp-session-id header from MCP', resp.status);
+    SESSION_ID = session;
+    return SESSION_ID;
+}
+async function rpcCall(method, params = {}, sessionId = null, timeoutMs = 8000) {
+    const sid = sessionId || SESSION_ID || (await initialize(timeoutMs));
+    const headers = { ...getHeaders(), 'MCP-SESSION-ID': sid };
+    const payload = method === 'initialize' || method === 'ping' || method.startsWith('tools/')
+        ? { jsonrpc: '2.0', id: '1', method, params }
+        : { jsonrpc: '2.0', id: '1', method: 'tools/call', params: { name: method, arguments: params } };
+    const resp = await fetch(MCP_ENDPOINT, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const newSid = resp.headers.get('mcp-session-id');
+    if (newSid)
+        SESSION_ID = newSid;
+    const text = await resp.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch (_err) {
+        const eventParsed = extractEventStreamData(text);
+        if (eventParsed) {
+            data = eventParsed;
+        }
+        else {
+            const snippet = text ? text.slice(0, 200) : '<empty>';
+            throw new MCPError(`Invalid JSON from MCP (status ${resp.status || 'unknown'}): ${snippet}`);
+        }
+    }
+    if (resp.status >= 400) {
+        const msg = data?.error?.message || `HTTP ${resp.status}`;
+        throw new MCPError(msg, resp.status);
+    }
+    if (data.error)
+        throw new MCPError(data.error.message || 'RPC error');
+    const result = data.result?.structuredContent?.result || data.result || data;
+    return [result, SESSION_ID];
+}
+/**
+ * Add a single group ID to params (for write operations).
+ * Uses the current folder's group ID if not specified.
+ */
+function withGroup(params, groupId = null) {
+    if (params.group_ids)
+        return params;
+    return { ...params, group_ids: [groupId || getCurrentGroupId()] };
+}
+/**
+ * Add hierarchical group IDs to params (for read operations).
+ * Queries current folder + all parent folders up to $HOME.
+ */
+function withHierarchicalGroups(params) {
+    if (params.group_ids)
+        return params;
+    return { ...params, group_ids: getHierarchicalGroupIds() };
+}
+module.exports = {
+    rpcCall,
+    withGroup,
+    withHierarchicalGroups,
+    initialize,
+    MCP_ENDPOINT,
+    getCurrentGroupId,
+    getHierarchicalGroupIds,
+    MCPError,
+};

package/dist/templates/claude/hooks/common/transcript-parser.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require('fs');
+const path = require('path');
+/**
+ * Parse a JSONL transcript file and extract work summary
+ */
+function parseTranscript(transcriptPath) {
+    const summary = {
+        filesModified: new Set(),
+        filesCreated: new Set(),
+        commandsRun: [],
+        toolsUsed: new Map(),
+        assistantSummary: '',
+        timestamp: new Date().toISOString(),
+        durationMs: 0,
+        totalCostUSD: 0,
+    };
+    if (!fs.existsSync(transcriptPath)) {
+        return summary;
+    }
+    try {
+        const content = fs.readFileSync(transcriptPath, 'utf8');
+        const lines = content.split('\n').filter((line) => line.trim());
+        let firstTimestamp = null;
+        let lastTimestamp = null;
+        let lastAssistantMessage = '';
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                // Skip side chains (subagent work - track separately if needed)
+                if (entry.isSidechain) {
+                    continue;
+                }
+                // Track timestamps for duration calculation
+                if (entry.timestamp) {
+                    const ts = new Date(entry.timestamp).getTime();
+                    if (firstTimestamp === null)
+                        firstTimestamp = ts;
+                    lastTimestamp = ts;
+                }
+                // Track costs
+                if (entry.costUSD) {
+                    summary.totalCostUSD += entry.costUSD;
+                }
+                // Process messages
+                if (entry.message) {
+                    processMessage(entry.message, summary);
+                    // Track last assistant message for summary
+                    if (entry.message.role === 'assistant') {
+                        const text = extractTextFromMessage(entry.message);
+                        if (text) {
+                            lastAssistantMessage = text;
+                        }
+                    }
+                }
+            }
+            catch (_parseErr) {
+                // Skip malformed lines, continue parsing
+                continue;
+            }
+        }
+        // Calculate duration
+        if (firstTimestamp !== null && lastTimestamp !== null) {
+            summary.durationMs = lastTimestamp - firstTimestamp;
+        }
+        // Set the assistant summary (truncate if too long)
+        summary.assistantSummary = truncateText(lastAssistantMessage, 500);
+    }
+    catch (_err) {
+        // Return empty summary on read errors
+    }
+    return summary;
+}
+/**
+ * Process a message entry and extract tool uses
+ */
+function processMessage(message, summary) {
+    if (!message.content)
+        return;
+    const contents = Array.isArray(message.content)
+        ? message.content
+        : [{ type: 'text', text: message.content }];
+    for (const content of contents) {
+        if (content.type === 'tool_use' && content.name) {
+            // Track tool usage count
+            const count = summary.toolsUsed.get(content.name) || 0;
+            summary.toolsUsed.set(content.name, count + 1);
+            // Extract file operations
+            if (content.input) {
+                processToolInput(content.name, content.input, summary);
+            }
+        }
+        if (content.type === 'tool_result' && content.name) {
+            // Also track from tool results if present
+            const count = summary.toolsUsed.get(content.name) || 0;
+            if (count === 0) {
+                summary.toolsUsed.set(content.name, 1);
+            }
+        }
+    }
+}
+/**
+ * Process tool input to extract file/command information
+ */
+function processToolInput(toolName, input, summary) {
+    const filePath = input.file_path;
+    switch (toolName) {
+        case 'Write':
+            if (filePath) {
+                summary.filesCreated.add(normalizePath(filePath));
+            }
+            break;
+        case 'Edit':
+        case 'MultiEdit':
+            if (filePath) {
+                summary.filesModified.add(normalizePath(filePath));
+            }
+            break;
+        case 'Bash':
+            if (input.command) {
+                // Track non-trivial commands (skip simple reads)
+                const cmd = input.command.trim();
+                if (!isReadOnlyCommand(cmd)) {
+                    summary.commandsRun.push(truncateText(cmd, 200));
+                }
+            }
+            break;
+        case 'NotebookEdit':
+            if (filePath) {
+                summary.filesModified.add(normalizePath(filePath));
+            }
+            break;
+    }
+}
+/**
+ * Check if a command is read-only (doesn't modify state)
+ */
+function isReadOnlyCommand(cmd) {
+    const readOnlyPatterns = [
+        /^ls\s/,
+        /^cat\s/,
+        /^head\s/,
+        /^tail\s/,
+        /^grep\s/,
+        /^find\s/,
+        /^which\s/,
+        /^echo\s/,
+        /^pwd$/,
+        /^git\s+status/,
+        /^git\s+log/,
+        /^git\s+diff/,
+        /^git\s+show/,
+        /^git\s+branch/,
+        /^npm\s+list/,
+        /^node\s+-[evp]/,
+    ];
+    return readOnlyPatterns.some((pattern) => pattern.test(cmd));
+}
+/**
+ * Extract text content from a message
+ */
+function extractTextFromMessage(message) {
+    if (typeof message.content === 'string') {
+        return message.content;
+    }
+    if (Array.isArray(message.content)) {
+        const textParts = message.content
+            .filter((c) => c.type === 'text' && c.text)
+            .map((c) => c.text);
+        return textParts.join('\n');
+    }
+    return '';
+}
+/**
+ * Normalize a file path (remove leading cwd, make relative)
+ */
+function normalizePath(filePath) {
+    const cwd = process.cwd();
+    if (filePath.startsWith(cwd)) {
+        return filePath.slice(cwd.length + 1);
+    }
+    // Remove leading slash for absolute paths outside cwd
+    if (filePath.startsWith('/')) {
+        return filePath;
+    }
+    return filePath;
+}
+/**
+ * Truncate text to a maximum length
+ */
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(0, maxLength - 3) + '...';
+}
+/**
+ * Find the most recent transcript file in a directory
+ */
+function findMostRecentTranscript(dir) {
+    if (!fs.existsSync(dir)) {
+        return null;
+    }
+    try {
+        const files = fs.readdirSync(dir)
+            .filter((f) => f.endsWith('.jsonl'))
+            .map((f) => {
+            const fullPath = path.join(dir, f);
+            return {
+                path: fullPath,
+                mtime: fs.statSync(fullPath).mtime.getTime(),
+            };
+        })
+            .sort((a, b) => b.mtime - a.mtime);
+        return files.length > 0 ? files[0].path : null;
+    }
+    catch (_err) {
+        return null;
+    }
+}
+/**
+ * Get files modified during the session
+ */
+function getFilesModified(summary) {
+    return summary.filesModified;
+}
+/**
+ * Get tool usage distribution
+ */
+function getToolDistribution(summary) {
+    return summary.toolsUsed;
+}
+/**
+ * Format duration in human-readable format
+ */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60)
+        return `${minutes}m ${remainingSeconds}s`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes}m`;
+}
+module.exports = {
+    parseTranscript,
+    findMostRecentTranscript,
+    getFilesModified,
+    getToolDistribution,
+    formatDuration,
+};