@tonycasey/lisa 0.5.13

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

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { ZEP_API_KEY, DEFAULT_GROUP_ID } = require('../../config');
+const ZEP_BASE_URL = 'https://api.getzep.com/api/v2';
+class ZepClientError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.name = 'ZepClientError';
+        this.status = status;
+    }
+}
+function getHeaders() {
+    if (!ZEP_API_KEY) {
+        throw new ZepClientError('ZEP_API_KEY is required for Zep Cloud');
+    }
+    return {
+        'Content-Type': 'application/json',
+        Authorization: `Api-Key ${ZEP_API_KEY}`,
+    };
+}
+async function zepFetch(path, options = {}, timeoutMs = 15000) {
+    const url = `${ZEP_BASE_URL}${path}`;
+    const resp = await fetch(url, {
+        ...options,
+        headers: {
+            ...getHeaders(),
+            ...(options.headers || {}),
+        },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const text = await resp.text();
+    let data;
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch (_err) {
+        throw new ZepClientError(`Invalid JSON from Zep (status ${resp.status}): ${text.slice(0, 200)}`, resp.status);
+    }
+    if (!resp.ok) {
+        const errorMsg = data.error?.message || data.error?.detail || `HTTP ${resp.status}`;
+        throw new ZepClientError(errorMsg, resp.status);
+    }
+    return data || data.data;
+}
+/**
+ * Add data to a user's knowledge graph
+ * Supports text, JSON, or message types
+ */
+async function addData(params) {
+    const body = {
+        user_id: params.user_id,
+        graph_id: params.graph_id,
+        type: params.type,
+        data: params.data,
+        source: params.source || 'lisa-memory',
+    };
+    return zepFetch('/graph/add', {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+}
+/**
+ * Search the knowledge graph for facts, nodes, or episodes
+ */
+async function search(params) {
+    const body = {
+        query: params.query,
+        user_id: params.user_id,
+        graph_id: params.graph_id,
+        limit: params.limit || 10,
+        search_scope: params.search_scope || 'facts',
+    };
+    return zepFetch('/graph/search', {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+}
+/**
+ * Ensure a user exists in Zep (creates if not present)
+ */
+async function ensureUser(userId, metadata) {
+    try {
+        // Try to get the user first
+        await zepFetch(`/users/${encodeURIComponent(userId)}`, { method: 'GET' });
+    }
+    catch (err) {
+        // User doesn't exist, create them
+        if (err instanceof ZepClientError && err.status === 404) {
+            await zepFetch('/users', {
+                method: 'POST',
+                body: JSON.stringify({
+                    user_id: userId,
+                    metadata: metadata || {},
+                }),
+            });
+        }
+        else {
+            throw err;
+        }
+    }
+}
+/**
+ * Get user's nodes from the knowledge graph
+ */
+async function getUserNodes(userId, limit = 50) {
+    const result = await zepFetch(`/graph/node/user/${encodeURIComponent(userId)}`, {
+        method: 'POST',
+        body: JSON.stringify({ limit }),
+    });
+    return result.nodes || [];
+}
+/**
+ * Add memory (convenience wrapper matching MCP interface)
+ * @param text The text content to store
+ * @param options Additional options
+ */
+async function addMemory(text, options = {}) {
+    const groupId = options.groupId || DEFAULT_GROUP_ID;
+    // Use graph_id for group-based storage (not user-specific)
+    const result = await addData({
+        graph_id: groupId,
+        type: 'text',
+        data: text,
+        source: options.source || 'lisa-memory',
+    });
+    return {
+        status: 'ok',
+        episode_uuid: result.episode_uuid,
+    };
+}
+/**
+ * Search memory facts (convenience wrapper matching MCP interface)
+ * @param query Search query
+ * @param options Additional options
+ */
+async function searchMemoryFacts(query, options = {}) {
+    const groupId = options.groupId || DEFAULT_GROUP_ID;
+    const result = await search({
+        query,
+        graph_id: groupId,
+        limit: options.limit || 10,
+        search_scope: 'facts',
+    });
+    return {
+        facts: result.facts || [],
+    };
+}
+/**
+ * Check if Zep Cloud is configured and reachable
+ */
+async function healthCheck() {
+    try {
+        if (!ZEP_API_KEY) {
+            return { status: 'error', message: 'ZEP_API_KEY not configured' };
+        }
+        // Try to list users as a health check
+        await zepFetch('/users', { method: 'GET' });
+        return { status: 'ok', message: 'Zep Cloud connected' };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { status: 'error', message };
+    }
+}
+module.exports = {
+    addMemory,
+    searchMemoryFacts,
+    addData,
+    search,
+    ensureUser,
+    getUserNodes,
+    healthCheck,
+    ZepClientError,
+    ZEP_BASE_URL,
+};

package/dist/templates/claude/hooks/session-start.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Claude Code - Session Start Hook
+ *
+ * Loads memory context from Graphiti MCP at the start of a new Claude session.
+ * This ensures Claude has access to prior work, tasks, and project context.
+ *
+ * Configuration: .claude/settings.json -> hooks.SessionStart
+ */
+const { rpcCall, withGroup, getCurrentGroupId, getHierarchicalGroupIds } = require('./common/mcp-client');
+const { detectRepo, detectBranch, repoTags, getUserName, getProjectAliases } = require('./common/context');
+const { detectFolderMetadata, formatFolderMetadata } = require('./common/group-id');
+// Configuration for recent memories display
+const RECENT_HOURS = 24;
+const MAX_RECENT_MEMORIES = 5;
+// Low-level relationship types to exclude (system noise, not meaningful work)
+const EXCLUDED_RELATIONSHIPS = new Set([
+    // System/debug noise
+    'USER_SUBMITS_DIRECTION', 'DIRECTION_IS_TOPIC',
+    'EXPANDED_ENTITY_TYPES_TRACKED',
+    // Overly granular
+    'TESTS', 'ASSESSES',
+]);
+function getTaskId(tags = []) {
+    const t = tags.find((x) => x.startsWith('task_id:'));
+    return t ? t.replace('task_id:', '') : null;
+}
+function getTaskNum(tags = []) {
+    const t = tags.find((x) => x.startsWith('task_num:'));
+    return t ? t.replace('task_num:', '') : null;
+}
+function getTaskStatus(tags = []) {
+    const t = tags.find((x) => x.startsWith('status:'));
+    return t ? t.replace('status:', '').toLowerCase() : 'unknown';
+}
+function pickLatest(a = {}, b = {}) {
+    const ad = a.created_at ? new Date(a.created_at).getTime() : 0;
+    const bd = b.created_at ? new Date(b.created_at).getTime() : 0;
+    return bd > ad ? b : a;
+}
+/**
+ * Filter memories to meaningful ones from the last N hours (excludes noise)
+ */
+function filterRecentMemories(memories, hoursAgo = RECENT_HOURS) {
+    const cutoff = new Date(Date.now() - hoursAgo * 60 * 60 * 1000);
+    return memories.filter((m) => {
+        // Must have timestamp
+        if (!m.created_at)
+            return false;
+        const created = new Date(m.created_at);
+        if (created < cutoff)
+            return false;
+        // Exclude known noise relationship types
+        if (m.name && EXCLUDED_RELATIONSHIPS.has(m.name)) {
+            return false;
+        }
+        return true;
+    });
+}
+/**
+ * Format a date relative to now (today, yesterday, or date)
+ */
+function formatRelativeDate(date) {
+    const now = new Date();
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
+    const dateOnly = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const time = date.toLocaleTimeString('en-US', {
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    });
+    if (dateOnly.getTime() === today.getTime()) {
+        return `Today ${time}`;
+    }
+    else if (dateOnly.getTime() === yesterday.getTime()) {
+        return `Yesterday ${time}`;
+    }
+    else {
+        const month = date.toLocaleString('en-US', { month: 'short' });
+        const day = date.getDate();
+        return `${month} ${day} ${time}`;
+    }
+}
+// Time window for grouping memories (in minutes)
+const GROUP_WINDOW_MINUTES = 5;
+/**
+ * Extract common theme from a group of memory facts
+ */
+function extractGroupSummary(memories) {
+    if (memories.length === 1) {
+        return memories[0].fact || memories[0].name || '<unknown>';
+    }
+    // Get all fact texts
+    const facts = memories.map((m) => m.fact || m.name || '').filter(Boolean);
+    if (!facts.length)
+        return `${memories.length} items`;
+    // Find common prefix/theme by looking for repeated phrases
+    const words = facts[0].split(/\s+/);
+    let commonPrefix = '';
+    // Find longest common prefix of words
+    for (let i = 0; i < Math.min(words.length, 8); i++) {
+        const prefix = words.slice(0, i + 1).join(' ');
+        const allMatch = facts.every((f) => f.startsWith(prefix));
+        if (allMatch) {
+            commonPrefix = prefix;
+        }
+        else {
+            break;
+        }
+    }
+    // Clean up the prefix (remove trailing articles, prepositions)
+    commonPrefix = commonPrefix.replace(/\s+(the|a|an|is|are|was|were|includes?|has|have|with|for|to|of|in|on|at)$/i, '');
+    if (commonPrefix.length > 15) {
+        return `${commonPrefix} (${memories.length} items)`;
+    }
+    // Fallback: use first fact truncated
+    const firstFact = facts[0];
+    if (firstFact.length > 60) {
+        return `${firstFact.slice(0, 57)}... (+${memories.length - 1} more)`;
+    }
+    return `${firstFact} (+${memories.length - 1} more)`;
+}
+/**
+ * Group memories by time window and create summaries
+ */
+function groupMemoriesByTime(memories, windowMinutes = GROUP_WINDOW_MINUTES) {
+    if (!memories.length)
+        return [];
+    // Sort by created_at descending (most recent first)
+    const sorted = [...memories].sort((a, b) => {
+        const ad = a.created_at ? new Date(a.created_at).getTime() : 0;
+        const bd = b.created_at ? new Date(b.created_at).getTime() : 0;
+        return bd - ad;
+    });
+    const groups = [];
+    let currentGroup = [];
+    let groupStartTime = null;
+    for (const memory of sorted) {
+        const memTime = memory.created_at ? new Date(memory.created_at).getTime() : 0;
+        if (groupStartTime === null) {
+            // Start new group
+            groupStartTime = memTime;
+            currentGroup = [memory];
+        }
+        else if (groupStartTime - memTime <= windowMinutes * 60 * 1000) {
+            // Within window, add to current group
+            currentGroup.push(memory);
+        }
+        else {
+            // Outside window, save current group and start new one
+            groups.push({
+                timestamp: new Date(groupStartTime),
+                memories: currentGroup,
+                summary: extractGroupSummary(currentGroup),
+            });
+            groupStartTime = memTime;
+            currentGroup = [memory];
+        }
+    }
+    // Don't forget the last group
+    if (currentGroup.length && groupStartTime !== null) {
+        groups.push({
+            timestamp: new Date(groupStartTime),
+            memories: currentGroup,
+            summary: extractGroupSummary(currentGroup),
+        });
+    }
+    return groups;
+}
+/**
+ * Format memory groups as summary lines with relative dates
+ * Grouped by time, limited to max groups
+ */
+function formatMemorySummary(memories, limit = MAX_RECENT_MEMORIES) {
+    const groups = groupMemoriesByTime(memories);
+    // Take top N groups
+    const topGroups = groups.slice(0, limit);
+    // Format each group
+    return topGroups.map((group) => {
+        const dateStr = formatRelativeDate(group.timestamp);
+        return `  ${dateStr} - ${group.summary}`;
+    });
+}
+async function main() {
+    const repo = detectRepo();
+    const branch = detectBranch();
+    const aliases = getProjectAliases(); // Get all aliases including folder name
+    const user = getUserName();
+    // Folder-based group hierarchy
+    const currentGroupId = getCurrentGroupId();
+    const hierarchicalGroups = getHierarchicalGroupIds();
+    const folderMetadata = detectFolderMetadata();
+    const folderType = formatFolderMetadata(folderMetadata);
+    const cwd = process.cwd();
+    let sessionId = null;
+    let facts = [];
+    const nodes = [];
+    let initReview = null;
+    // Load init-review memory first (codebase summary)
+    try {
+        const initParams = {
+            query: 'init-review',
+            max_facts: 1,
+            order: 'desc',
+            group_ids: hierarchicalGroups,
+            tags: ['type:init-review'],
+        };
+        const [initResp, sid] = await rpcCall('search_memory_facts', initParams, sessionId);
+        sessionId = sid;
+        const initFacts = initResp?.result?.facts || initResp?.facts || [];
+        if (initFacts.length > 0) {
+            // Get the most recent init-review
+            const fact = initFacts[0];
+            initReview = fact.fact || fact.name || null;
+        }
+    }
+    catch (_err) {
+        // Silently continue if init-review load fails
+    }
+    // Load recent facts/nodes from memory using hierarchical groups
+    try {
+        const allFacts = [];
+        const seenUuids = new Set();
+        // Query with hierarchical groups (current folder + all parents)
+        const recentParams = { query: '*', max_facts: 100, order: 'desc', group_ids: hierarchicalGroups };
+        const [recentResp, sid] = await rpcCall('search_memory_facts', recentParams, sessionId);
+        sessionId = sid;
+        const recentFacts = recentResp?.result?.facts || recentResp?.facts || [];
+        for (const fact of recentFacts) {
+            const uuid = fact.uuid || `${fact.name}-${fact.fact}`;
+            if (!seenUuids.has(uuid)) {
+                seenUuids.add(uuid);
+                allFacts.push(fact);
+            }
+        }
+        // Also query by repo aliases to catch any repo-specific memories
+        for (const alias of aliases) {
+            const baseParams = { query: alias, tags: repoTags({ repo: alias, branch }) };
+            const factParams = { ...baseParams, max_facts: 50, order: 'desc', group_ids: hierarchicalGroups };
+            const [factResp] = await rpcCall('search_memory_facts', factParams, sessionId);
+            const aliasedFacts = factResp?.result?.facts || factResp?.facts || [];
+            for (const fact of aliasedFacts) {
+                const uuid = fact.uuid || `${fact.name}-${fact.fact}`;
+                if (!seenUuids.has(uuid)) {
+                    seenUuids.add(uuid);
+                    allFacts.push(fact);
+                }
+            }
+        }
+        facts = allFacts;
+        // Fall back to nodes if no facts found
+        if (!facts.length) {
+            for (const alias of aliases) {
+                const baseParams = { query: alias, tags: repoTags({ repo: alias, branch }) };
+                const nodeParams = { ...baseParams, max_nodes: 20, group_ids: hierarchicalGroups };
+                const [nodeResp] = await rpcCall('search_nodes', nodeParams, sessionId);
+                const aliasedNodes = nodeResp?.result?.nodes || nodeResp?.nodes || [];
+                for (const node of aliasedNodes) {
+                    const uuid = node.uuid || `${node.name}-${node.fact}`;
+                    if (!seenUuids.has(uuid)) {
+                        seenUuids.add(uuid);
+                        nodes.push(node);
+                    }
+                }
+            }
+        }
+    }
+    catch (_err) {
+        // Silently continue if memory load fails - don't block session start
+    }
+    // Load tasks for this repo (query all aliases with hierarchical groups)
+    const taskNodes = [];
+    try {
+        const seenTaskUuids = new Set();
+        for (const alias of aliases) {
+            const taskParams = {
+                query: 'task',
+                tags: ['type:task', ...repoTags({ repo: alias, branch })],
+                max_nodes: 200,
+                group_ids: hierarchicalGroups,
+            };
+            const [taskResp] = await rpcCall('search_nodes', taskParams, sessionId);
+            const aliasedTasks = taskResp?.result?.nodes || taskResp?.nodes || [];
+            for (const task of aliasedTasks) {
+                const uuid = task.uuid || `${task.name}-${task.fact}`;
+                if (!seenTaskUuids.has(uuid)) {
+                    seenTaskUuids.add(uuid);
+                    taskNodes.push(task);
+                }
+            }
+        }
+    }
+    catch (_err) {
+        // Silently continue if task load fails
+    }
+    // Process items
+    const repoLabel = `${repo}${branch ? ' (' + branch + ')' : ''}`;
+    const items = facts.length ? facts : nodes;
+    // Filter to last 24 hours and format for display
+    const recentItems = filterRecentMemories(items, RECENT_HOURS);
+    const recentFormatted = formatMemorySummary(recentItems, MAX_RECENT_MEMORIES);
+    // Deduplicate tasks by key (task_num or task_id)
+    const tasksByKey = new Map();
+    taskNodes.forEach((n) => {
+        const key = getTaskNum(n.tags) || getTaskId(n.tags);
+        if (!key)
+            return;
+        const existing = tasksByKey.get(key);
+        const latest = existing ? pickLatest(existing, n) : n;
+        tasksByKey.set(key, latest);
+    });
+    const tasks = Array.from(tasksByKey.entries()).map(([key, n]) => {
+        const status = getTaskStatus(n.tags);
+        const title = n.name || n.fact || n.uuid || '<untitled>';
+        const blocked = (n.tags || []).filter((t) => t.startsWith('blocked_by:')).map((t) => t.replace('blocked_by:', ''));
+        return { key, status, title, blocked, created_at: n.created_at };
+    });
+    tasks.sort((a, b) => {
+        const ad = a.created_at ? new Date(a.created_at).getTime() : 0;
+        const bd = b.created_at ? new Date(b.created_at).getTime() : 0;
+        return bd - ad;
+    });
+    // Count tasks by status
+    const counts = {
+        ready: 0,
+        'in-progress': 0,
+        blocked: 0,
+        done: 0,
+        closed: 0,
+        unknown: 0,
+    };
+    tasks.forEach((t) => {
+        const key = counts[t.status] === undefined ? 'unknown' : t.status;
+        counts[key] += 1;
+    });
+    const active = tasks.filter((t) => t.status === 'in-progress');
+    const ready = tasks.filter((t) => t.status === 'ready');
+    // Build output - show folder context with type
+    const lines = [];
+    lines.push(`Memory loaded for session start.`);
+    // Show folder path with detected type (e.g., "TypeScript/React project")
+    const folderDisplay = cwd.replace(process.env.HOME || '', '~');
+    lines.push(`User: ${user} | Folder: ${folderDisplay} (${folderType})`);
+    lines.push(`Repo: ${repoLabel}`);
+    // Show init-review (codebase summary) if available
+    if (initReview) {
+        lines.push('');
+        lines.push('Codebase Summary:');
+        lines.push(`  ${initReview}`);
+        lines.push('');
+    }
+    // Show recent memories from last 24 hours
+    if (recentFormatted.length) {
+        lines.push(`Recent memories (last ${RECENT_HOURS}h):`);
+        lines.push(...recentFormatted);
+    }
+    else if (items.length) {
+        lines.push(`Recent memories (last ${RECENT_HOURS}h): none (older memories exist)`);
+    }
+    if (tasks.length) {
+        const summaryParts = [];
+        if (counts['in-progress'])
+            summaryParts.push(`${counts['in-progress']} in-progress`);
+        if (counts.ready)
+            summaryParts.push(`${counts.ready} ready`);
+        if (counts.blocked)
+            summaryParts.push(`${counts.blocked} blocked`);
+        if (counts.done)
+            summaryParts.push(`${counts.done} done`);
+        if (counts.closed)
+            summaryParts.push(`${counts.closed} closed`);
+        lines.push(`Tasks: ${summaryParts.join(', ') || 'none active'}`);
+        if (active.length) {
+            lines.push(`Active: ${active[0].key} - ${active[0].title}`);
+        }
+        if (ready.length) {
+            const readyList = ready.slice(0, 2).map((t) => `${t.key} - ${t.title}`).join(' | ');
+            lines.push(`Ready: ${readyList}`);
+        }
+    }
+    else {
+        lines.push('Tasks: none found for this repo');
+    }
+    // Output goes to Claude as system-reminder context (stdout)
+    console.log(lines.join('\n'));
+    // Visible confirmation to user (stderr) - brief summary
+    const itemCount = items.length;
+    const taskCount = tasks.length;
+    const summary = itemCount || taskCount
+        ? `${itemCount} memories, ${taskCount} tasks`
+        : 'no prior context';
+    console.error(`[Memory loaded: ${summary}]`);
+}
+main().catch((err) => {
+    // Don't block session start on errors - just log and exit cleanly
+    console.log(`Memory load skipped: ${err.message}`);
+    process.exit(0);
+});