@tonycasey/lisa 0.5.13

package/dist/templates/agents/skills/lisa/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: lisa
+description: "Lisa - intelligent assistant for memory and tasks. Triggers on 'lisa', 'hey lisa', or addressing lisa directly."
+---
+
+## Purpose
+Primary interface for project memory, tasks, and knowledge. Routes natural language requests to appropriate capabilities.
+
+## Triggers
+Use when the user addresses "lisa" directly:
+- "hey lisa, ..."
+- "lisa, ..."
+- "ask lisa ..."
+- "lisa knows ..."
+
+## Capabilities
+
+### Memory Operations
+- "lisa, show me recent memories" → Load recent facts
+- "lisa, what do you know about X" → Search memories for topic X
+- "lisa, remember that X" → Store a memory
+- "lisa, recall X" → Search with specific query
+
+### Task Operations
+- "lisa, what tasks are we working on" → List tasks
+- "lisa, add task X" → Create new task
+- "lisa, task status" → Show task overview
+
+### Storage Operations
+- "lisa, what storage are we using" → Show current storage mode
+- "lisa, storage status" → Show mode and connection status
+- "lisa, switch to local" → Switch to local Docker mode
+- "lisa, switch to zep-cloud" → Switch to Zep Cloud mode
+- "lisa, use docker" → Switch to local mode
+- "lisa, use cloud storage" → Switch to Zep Cloud mode
+
+## How to use
+1) Parse user intent from "lisa" request
+2) Route to appropriate underlying command:
+   - Memory recall: `node .agents/skills/memory/scripts/memory.js load --cache`
+   - Memory search: `node .agents/skills/memory/scripts/memory.js load --cache --query "<topic>"`
+   - Memory add: `node .agents/skills/memory/scripts/memory.js add "<text>" --cache`
+   - Task list: `node .agents/skills/tasks/scripts/tasks.js list --cache`
+   - Task add: `node .agents/skills/tasks/scripts/tasks.js add "<text>" --cache`
+   - Storage status: `node .agents/skills/lisa/scripts/storage.js status --cache`
+   - Storage switch: `node .agents/skills/lisa/scripts/storage.js switch <mode> --cache`
+3) Summarize results conversationally
+
+## Intent Mapping
+
+| User Says | Intent | Route To |
+|-----------|--------|----------|
+| "show memories", "recent memories", "what's stored" | recall | memory load |
+| "what do you know about X", "recall X", "search X" | search | memory load --query X |
+| "remember that X", "save this", "note that X" | remember | memory add X |
+| "tasks", "what are we working on", "todo" | list tasks | tasks list |
+| "add task X", "new task X", "create task X" | add task | tasks add X |
+| "what storage", "current mode", "storage status" | storage status | storage status |
+| "switch to local", "use docker", "local mode" | switch local | storage switch local |
+| "switch to zep", "use cloud", "zep-cloud mode" | switch zep-cloud | storage switch zep-cloud |
+
+## Personality Guidelines
+- Lisa is helpful and knowledgeable
+- Responses are conversational but concise
+- Acknowledges when memory is empty or query returns nothing
+- Suggests related queries when appropriate
+
+## Output Formatting
+- Always prefix Lisa's responses with the 👧 emoji followed by a space
+- Use the emoji at the start of section headers when presenting data:
+  - `👧  Recent Memories:` for memory listings
+  - `👧  Tasks:` for task listings
+  - `👧  Lisa says:` for conversational responses
+- Example format:
+  ```
+  👧  Recent Memories:
+  1. **Memory title** (date)
+     - Details here
+  ```
+
+## I/O Contract
+Underlying scripts return JSON:
+- Memory recall: `{ status: "ok", action: "load", facts: [...] }`
+- Memory add: `{ status: "ok", action: "add", text: "..." }`
+- Task list: `{ status: "ok", action: "list", tasks: [...] }`
+- Task add: `{ status: "ok", action: "add", task: {...} }`
+- Storage status: `{ status: "ok", action: "status", mode: "local|zep-cloud", isConnected: true|false }`
+- Storage switch: `{ status: "ok", action: "switch", previousMode: "...", newMode: "...", verified: true|false }`
+
+## Cross-model checklist
+- Claude: Keep instructions concise; conversational output format
+- Gemini: Use explicit commands; avoid model-specific tokens

package/dist/templates/agents/skills/lisa/scripts/storage.js

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+"use strict";
+// Lisa storage mode management script.
+// Commands:
+//   node storage.js status [--cache]         Show current storage mode and connection status
+//   node storage.js switch <mode> [--cache]  Switch to local or zep-cloud mode
+// Options:
+//   --cache  Write successful responses to cache and use as fallback on errors.
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+// Constants
+const ZEP_BASE_URL = 'https://api.getzep.com/api/v2';
+const DEFAULT_LOCAL_ENDPOINT = 'http://localhost:8010/mcp/';
+const DEFAULT_ZEP_ENDPOINT = 'https://api.getzep.com/mcp/';
+// Read environment config from .agents/skills/.env
+function readEnvConfig() {
+    // Path: .agents/skills/lisa/scripts/ -> .agents/skills/.env (2 levels up)
+    const envPath = path.join(__dirname, '..', '..', '.env');
+    const out = {};
+    try {
+        const raw = fs.readFileSync(envPath, 'utf8');
+        raw.split(/\r?\n/).forEach((line) => {
+            if (!line || line.startsWith('#'))
+                return;
+            const idx = line.indexOf('=');
+            if (idx === -1)
+                return;
+            const key = line.slice(0, idx).trim();
+            const val = line.slice(idx + 1).trim();
+            out[key] = val;
+        });
+    }
+    catch (_) {
+        // optional .env; ignore if missing
+    }
+    return out;
+}
+// Update STORAGE_MODE in .agents/skills/.env (preserves comments and other vars)
+function updateEnvStorageMode(newMode) {
+    const envPath = path.join(__dirname, '..', '..', '.env');
+    let content;
+    try {
+        content = fs.readFileSync(envPath, 'utf8');
+    }
+    catch (_) {
+        // Create new .env if it doesn't exist
+        content = '';
+    }
+    const lines = content.split(/\r?\n/);
+    let foundMode = false;
+    let foundEndpoint = false;
+    const newEndpoint = newMode === 'zep-cloud' ? DEFAULT_ZEP_ENDPOINT : DEFAULT_LOCAL_ENDPOINT;
+    const updatedLines = lines.map((line) => {
+        // Update STORAGE_MODE
+        if (line.startsWith('STORAGE_MODE=') || line.startsWith('STORAGE_MODE =')) {
+            foundMode = true;
+            return `STORAGE_MODE=${newMode}`;
+        }
+        // Update GRAPHITI_ENDPOINT
+        if (line.startsWith('GRAPHITI_ENDPOINT=') || line.startsWith('GRAPHITI_ENDPOINT =')) {
+            foundEndpoint = true;
+            return `GRAPHITI_ENDPOINT=${newEndpoint}`;
+        }
+        return line;
+    });
+    // Add STORAGE_MODE if not found
+    if (!foundMode) {
+        // Find a good place to insert (after GRAPHITI_GROUP_ID or at end)
+        const groupIdx = updatedLines.findIndex((l) => l.startsWith('GRAPHITI_GROUP_ID'));
+        if (groupIdx !== -1) {
+            updatedLines.splice(groupIdx + 1, 0, `STORAGE_MODE=${newMode}`);
+        }
+        else {
+            updatedLines.push(`STORAGE_MODE=${newMode}`);
+        }
+    }
+    // Add GRAPHITI_ENDPOINT if not found
+    if (!foundEndpoint) {
+        const modeIdx = updatedLines.findIndex((l) => l.startsWith('STORAGE_MODE'));
+        if (modeIdx !== -1) {
+            updatedLines.splice(modeIdx + 1, 0, `GRAPHITI_ENDPOINT=${newEndpoint}`);
+        }
+        else {
+            updatedLines.push(`GRAPHITI_ENDPOINT=${newEndpoint}`);
+        }
+    }
+    // Write back
+    fs.writeFileSync(envPath, updatedLines.join('\n'), 'utf8');
+}
+// Check if Docker daemon is running
+function checkDockerRunning() {
+    try {
+        execSync('docker info', { stdio: 'pipe', timeout: 5000 });
+        return { running: true };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('Cannot connect') || message.includes('Is the docker daemon running')) {
+            return { running: false, error: 'Docker daemon is not running. Start Docker Desktop or run `dockerd`.' };
+        }
+        if (message.includes('command not found') || message.includes('not recognized')) {
+            return { running: false, error: 'Docker is not installed. Install Docker from https://docker.com' };
+        }
+        return { running: false, error: `Docker check failed: ${message}` };
+    }
+}
+// Check if ZEP_API_KEY exists
+function checkZepApiKeyExists(env) {
+    const apiKey = env.ZEP_API_KEY || process.env.ZEP_API_KEY;
+    if (apiKey && apiKey.length > 0 && !apiKey.startsWith('${')) {
+        return { exists: true };
+    }
+    return {
+        exists: false,
+        error: 'ZEP_API_KEY not configured. Add ZEP_API_KEY to .agents/.env or set it as an environment variable.'
+    };
+}
+// Ping local MCP endpoint
+async function pingLocalMcp(endpoint) {
+    try {
+        const body = {
+            jsonrpc: '2.0',
+            id: 'ping',
+            method: 'initialize',
+            params: {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'storage-skill', version: '0.1.0' },
+            },
+        };
+        const resp = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(10000),
+        });
+        if (resp.ok) {
+            return { reachable: true };
+        }
+        return { reachable: false, error: `HTTP ${resp.status}` };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { reachable: false, error: message };
+    }
+}
+// Ping Zep Cloud API
+async function pingZepCloud(apiKey) {
+    try {
+        const resp = await fetch(`${ZEP_BASE_URL}/users`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Api-Key ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        // Even 404 or 400 means the API is reachable and auth worked
+        if (resp.ok || resp.status === 404 || resp.status === 400) {
+            return { reachable: true };
+        }
+        if (resp.status === 401 || resp.status === 403) {
+            return { reachable: false, error: 'Invalid API key' };
+        }
+        return { reachable: false, error: `HTTP ${resp.status}` };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { reachable: false, error: message };
+    }
+}
+// Argument parsing
+const args = process.argv.slice(2);
+function popFlag(name, fallback) {
+    const idx = args.indexOf(name);
+    if (idx === -1)
+        return fallback;
+    const val = args[idx + 1];
+    args.splice(idx, 2);
+    return val ?? fallback;
+}
+function hasFlag(name) {
+    const idx = args.indexOf(name);
+    if (idx === -1)
+        return false;
+    args.splice(idx, 1);
+    return true;
+}
+const command = args.shift() ?? '';
+const useCache = hasFlag('--cache');
+const targetMode = args.shift() ?? '';
+const cacheFile = path.join(__dirname, '..', 'cache', 'storage.log');
+function writeCache(obj) {
+    try {
+        const cacheDir = path.dirname(cacheFile);
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        const line = JSON.stringify({ ts: new Date().toISOString(), ...obj });
+        fs.appendFileSync(cacheFile, `${line}\n`, 'utf8');
+    }
+    catch (_) {
+        // cache failures should not crash command
+    }
+}
+function readCacheFallback() {
+    try {
+        const data = fs.readFileSync(cacheFile, 'utf8').trim().split('\n').filter(Boolean);
+        if (!data.length)
+            return null;
+        return data.slice(-1).map((l) => JSON.parse(l))[0];
+    }
+    catch (_) {
+        return null;
+    }
+}
+// Status command
+async function statusCommand() {
+    const env = readEnvConfig();
+    const mode = env.STORAGE_MODE || process.env.STORAGE_MODE || 'local';
+    const endpoint = env.GRAPHITI_ENDPOINT || process.env.GRAPHITI_ENDPOINT || DEFAULT_LOCAL_ENDPOINT;
+    const groupId = env.GRAPHITI_GROUP_ID || process.env.GRAPHITI_GROUP_ID || 'lisa';
+    let isConnected = false;
+    let connectionError;
+    if (mode === 'zep-cloud') {
+        const apiKey = env.ZEP_API_KEY || process.env.ZEP_API_KEY || '';
+        if (apiKey && !apiKey.startsWith('${')) {
+            const result = await pingZepCloud(apiKey);
+            isConnected = result.reachable;
+            connectionError = result.error;
+        }
+        else {
+            connectionError = 'ZEP_API_KEY not configured';
+        }
+    }
+    else if (mode === 'local') {
+        const dockerCheck = checkDockerRunning();
+        if (!dockerCheck.running) {
+            connectionError = dockerCheck.error;
+        }
+        else {
+            const result = await pingLocalMcp(endpoint);
+            isConnected = result.reachable;
+            connectionError = result.error;
+        }
+    }
+    else {
+        connectionError = `Unknown mode: ${mode}`;
+    }
+    return {
+        status: 'ok',
+        action: 'status',
+        mode,
+        endpoint,
+        groupId,
+        isConnected,
+        ...(connectionError ? { connectionError } : {}),
+    };
+}
+// Switch command
+async function switchCommand(newMode) {
+    const validModes = ['local', 'zep-cloud'];
+    if (!validModes.includes(newMode)) {
+        return {
+            status: 'error',
+            action: 'switch',
+            message: `Invalid mode: ${newMode}. Valid modes are: ${validModes.join(', ')}`,
+        };
+    }
+    const env = readEnvConfig();
+    const previousMode = env.STORAGE_MODE || process.env.STORAGE_MODE || 'local';
+    // Same mode check
+    if (previousMode === newMode) {
+        return {
+            status: 'ok',
+            action: 'switch',
+            previousMode,
+            newMode,
+            verified: true,
+            message: `Already using ${newMode} mode.`,
+        };
+    }
+    // Validation before switching
+    if (newMode === 'local') {
+        const dockerCheck = checkDockerRunning();
+        if (!dockerCheck.running) {
+            return {
+                status: 'error',
+                action: 'switch',
+                message: `Cannot switch to local: ${dockerCheck.error}`,
+            };
+        }
+    }
+    else if (newMode === 'zep-cloud') {
+        const zepCheck = checkZepApiKeyExists(env);
+        if (!zepCheck.exists) {
+            return {
+                status: 'error',
+                action: 'switch',
+                message: `Cannot switch to zep-cloud: ${zepCheck.error}`,
+            };
+        }
+    }
+    // Update the .env file
+    updateEnvStorageMode(newMode);
+    // Re-read config to get updated endpoint
+    const updatedEnv = readEnvConfig();
+    const newEndpoint = updatedEnv.GRAPHITI_ENDPOINT || (newMode === 'zep-cloud' ? DEFAULT_ZEP_ENDPOINT : DEFAULT_LOCAL_ENDPOINT);
+    // Verify connection after switch
+    let verified = false;
+    let verifyError;
+    if (newMode === 'zep-cloud') {
+        const apiKey = updatedEnv.ZEP_API_KEY || process.env.ZEP_API_KEY || '';
+        const result = await pingZepCloud(apiKey);
+        verified = result.reachable;
+        verifyError = result.error;
+    }
+    else {
+        const result = await pingLocalMcp(newEndpoint);
+        verified = result.reachable;
+        verifyError = result.error;
+    }
+    const message = verified
+        ? `Successfully switched from ${previousMode} to ${newMode}. Connection verified.`
+        : `Switched from ${previousMode} to ${newMode}, but connection verification failed: ${verifyError}`;
+    return {
+        status: 'ok',
+        action: 'switch',
+        previousMode,
+        newMode,
+        endpoint: newEndpoint,
+        verified,
+        message,
+        ...(verifyError && !verified ? { verifyError } : {}),
+    };
+}
+async function main() {
+    try {
+        if (!['status', 'switch'].includes(command)) {
+            throw new Error('command must be status|switch');
+        }
+        let out;
+        if (command === 'status') {
+            out = await statusCommand();
+        }
+        else {
+            // switch
+            if (!targetMode) {
+                throw new Error('switch requires a mode argument (local or zep-cloud)');
+            }
+            out = await switchCommand(targetMode);
+        }
+        if (useCache && out.status === 'ok') {
+            writeCache(out);
+        }
+        console.log(JSON.stringify(out, null, 2));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const fallback = useCache ? readCacheFallback() : null;
+        if (fallback) {
+            console.log(JSON.stringify({ status: 'fallback', error: message, fallback }, null, 2));
+            return;
+        }
+        console.error(message);
+        process.exit(1);
+    }
+}
+main();

package/dist/templates/agents/skills/memory/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: memory
+description: "Load or remember project memory via Graphiti MCP; triggers on 'load memory', 'recall', or 'remember', usable by any model (Claude, Gemini)."
+---
+
+## Purpose
+Reusable memory helper that routes remember/recall requests to Graphiti MCP while staying model-neutral and providing cache fallback.
+
+## Triggers
+Use when the user says things like: "load memory", "recall notes", "remember", "pull saved context", "fetch past tasks".
+
+## How to use
+1) For recall: run `scripts/memory.js load --cache [--query <q>] [--limit 10] [--group <id>]`. Reads Graphiti facts and prints JSON. Uses cache if MCP is down.
+2) For remember: run `scripts/memory.js add "<text>" --cache [--group <id>] [--tag foo] [--source <src>]` to append an episode.
+3) Endpoint/group: reads ${GRAPHITI_ENDPOINT} / ${GRAPHITI_GROUP_ID} from `.agents/.env` (written by init); see root `AGENTS.md` for canonical defaults.
+4) Cache fallback: stored at `cache/memory.log` inside this skill. On failure, last cached result is returned with `status: "fallback"`.
+5) Keep prompts model-neutral; avoid role tokens. Models just orchestrate the script and summarize results to the user.
+
+## I/O contract (examples)
+- Recall: output JSON `{ status: "ok", action: "load", group, query, facts: [...] }`.
+- Remember: JSON `{ status: "ok", action: "add", group, text }`.
+- Fallback: JSON `{ status: "fallback", error, fallback: <last cached object> }`.
+
+## Cross-model checklist
+- Claude: confirm concise trigger phrasing; keep under system limits; avoid markdown-heavy instructions.
+- Gemini: ensure commands are explicit; avoid model-specific tokens; keep JSON small.
+
+## Notes
+- Script is Node.js; relies on global `fetch` (Node ≥18). If older runtime, `node --experimental-fetch`.
+- Facts query defaults to `*` with `max_facts=10`; tune via `--limit` and `--query`.
+- Safe to relocate: skill lives in `.agents/skills/memory` to remain decoupled from model-specific bindings.