@tonycasey/lisa 0.5.13

package/dist/templates/claude/hooks/user-prompt-submit.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Claude Code - User Prompt Submit Hook
+ *
+ * This hook runs before a user's prompt is submitted to Claude.
+ * It can be used to validate, enhance, or log prompts.
+ *
+ * Configuration: .claude/settings.json -> hooks.UserPromptSubmit
+ *
+ * Note: This hook is optional and only runs if configured.
+ * If the hook exits with non-zero status, the prompt submission is cancelled.
+ */
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { PROJECT_ROOT, PROMPT_SKILL_PATH, DEV_DIR } = require('../config');
+/**
+ * Validate prompt for potentially problematic patterns
+ */
+function validatePrompt(prompt) {
+    const warnings = [];
+    // Check for overly broad requests
+    if (prompt.toLowerCase().includes('delete all') ||
+        prompt.toLowerCase().includes('remove everything')) {
+        warnings.push('  Destructive operation detected - please be specific');
+    }
+    // Check for requests without context
+    if (prompt.length < 10) {
+        warnings.push('  Very short prompt - consider providing more context');
+    }
+    return warnings;
+}
+/**
+ * Enhance prompt with project context if needed
+ */
+function enhancePrompt(prompt) {
+    const suggestions = [];
+    if (prompt.toLowerCase().includes('architecture') ||
+        prompt.toLowerCase().includes('structure')) {
+        const archPath = path.join(DEV_DIR, 'architecture.md');
+        if (fs.existsSync(archPath)) {
+            suggestions.push(' Consider referencing @.dev/architecture.md for context');
+        }
+    }
+    if (prompt.toLowerCase().includes('todo') ||
+        prompt.toLowerCase().includes('task')) {
+        const todoPath = path.join(DEV_DIR, 'todo.md');
+        if (fs.existsSync(todoPath)) {
+            suggestions.push(' Your todo list is available at @.dev/todo.md');
+        }
+    }
+    return suggestions;
+}
+/**
+ * Log prompt for analytics (optional)
+ */
+function logPrompt(prompt) {
+    const logPath = path.join(DEV_DIR, '.prompt-log.jsonl');
+    const logEntry = {
+        timestamp: new Date().toISOString(),
+        promptLength: prompt.length,
+        promptPreview: prompt.substring(0, 100)
+    };
+    try {
+        fs.appendFileSync(logPath, JSON.stringify(logEntry) + '\n');
+    }
+    catch (_error) {
+        // Silently fail if logging doesn't work
+    }
+}
+/**
+ * Check if Graphiti MCP server is available
+ * Returns true if server responds, false otherwise
+ */
+async function isGraphitiAvailable() {
+    // Read endpoint from .env file (same logic as prompt skill)
+    const envPath = path.join(PROJECT_ROOT, '.agents', 'skills', '.env');
+    let endpoint = 'http://localhost:8010/mcp/';
+    try {
+        if (fs.existsSync(envPath)) {
+            const raw = fs.readFileSync(envPath, 'utf8');
+            const lines = raw.split(/\r?\n/);
+            for (const line of lines) {
+                if (line.startsWith('GRAPHITI_ENDPOINT=')) {
+                    endpoint = line.slice('GRAPHITI_ENDPOINT='.length).trim();
+                    break;
+                }
+            }
+        }
+    }
+    catch {
+        // Use default endpoint
+    }
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 2000);
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 'health',
+                method: 'ping',
+                params: {}
+            }),
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        return response.ok || response.status === 400; // 400 means server is up but method not found
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Store prompt to Graphiti MCP for cross-session memory
+ * Graphiti's LLM automatically classifies the content as:
+ * - KeyDecision, DirectionChange, ArchitecturalChoice, Preference, etc.
+ * Classification happens server-side based on entity_types in config.yaml
+ */
+async function storeToGraphiti(prompt) {
+    if (!fs.existsSync(PROMPT_SKILL_PATH)) {
+        return null; // Silently skip if skill not found
+    }
+    // Check if Graphiti is available before attempting storage
+    const available = await isGraphitiAvailable();
+    if (!available) {
+        return { status: 'unavailable' };
+    }
+    return new Promise((resolve) => {
+        const child = spawn('node', [
+            PROMPT_SKILL_PATH,
+            '--text', prompt,
+            '--role', 'user',
+            '--source', 'user-prompt' // Graphiti LLM classifies content automatically
+        ], {
+            cwd: PROJECT_ROOT,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => { stdout += data; });
+        child.stderr.on('data', (data) => { stderr += data; });
+        child.on('close', (code) => {
+            if (code === 0) {
+                try {
+                    const result = JSON.parse(stdout);
+                    resolve(result);
+                }
+                catch {
+                    resolve({ status: 'ok', raw: stdout.trim() });
+                }
+            }
+            else {
+                // Check if it's a connection error
+                const errorMsg = stderr.trim() || `exit code ${code}`;
+                if (errorMsg.includes('fetch failed') || errorMsg.includes('ECONNREFUSED')) {
+                    resolve({ status: 'unavailable' });
+                }
+                else {
+                    resolve({ status: 'error', error: errorMsg });
+                }
+            }
+        });
+        child.on('error', (err) => {
+            if (err.message.includes('fetch failed') || err.message.includes('ECONNREFUSED')) {
+                resolve({ status: 'unavailable' });
+            }
+            else {
+                resolve({ status: 'error', error: err.message });
+            }
+        });
+        // Timeout after 5 seconds
+        setTimeout(() => {
+            child.kill();
+            resolve({ status: 'timeout' });
+        }, 5000);
+    });
+}
+/**
+ * Main execution - reads JSON from stdin (Claude Code hook protocol)
+ */
+function main() {
+    let inputData = '';
+    // Read JSON from stdin
+    process.stdin.on('data', (chunk) => {
+        inputData += chunk;
+    });
+    process.stdin.on('end', async () => {
+        try {
+            const hookInput = JSON.parse(inputData);
+            const prompt = hookInput.prompt || '';
+            if (!prompt) {
+                console.log('  No prompt in hook input');
+                process.exit(0);
+            }
+            // Log what we captured for debugging
+            console.log(`Captured prompt (${prompt.length} chars): "${prompt.substring(0, 80)}${prompt.length > 80 ? '...' : ''}"`);
+            // Validate prompt
+            const warnings = validatePrompt(prompt);
+            if (warnings.length > 0) {
+                warnings.forEach(warning => console.log(warning));
+            }
+            // Enhance prompt with suggestions
+            const suggestions = enhancePrompt(prompt);
+            if (suggestions.length > 0) {
+                suggestions.forEach(suggestion => console.log(suggestion));
+            }
+            // Log prompt for analytics
+            logPrompt(prompt);
+            // Store to Graphiti MCP for cross-session memory
+            const graphitiResult = await storeToGraphiti(prompt);
+            if (graphitiResult) {
+                if (graphitiResult.status === 'ok') {
+                    // Successfully stored - no need to show message
+                }
+                else if (graphitiResult.status === 'skipped') {
+                    // Duplicate - silently skip
+                }
+                else if (graphitiResult.status === 'unavailable') {
+                    console.log('  lisa works but needs further setup to persist her memory');
+                }
+                else if (graphitiResult.status === 'error') {
+                    // Only show actual errors, not connection issues
+                    console.log('  lisa works but needs further setup to persist her memory');
+                }
+                else if (graphitiResult.status === 'timeout') {
+                    console.log('  lisa works but needs further setup to persist her memory');
+                }
+            }
+            // Exit with 0 to allow prompt to proceed
+            process.exit(0);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(` Failed to parse hook input: ${message}`);
+            // Exit with 0 to not block the prompt on errors
+            process.exit(0);
+        }
+    });
+}
+// Run if called directly
+if (require.main === module) {
+    try {
+        main();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(` Prompt validation failed: ${message}`);
+        // Exit with 0 to not block the prompt
+        process.exit(0);
+    }
+}
+module.exports = { validatePrompt, enhancePrompt, logPrompt };

package/dist/templates/claude/settings.json

@@ -0,0 +1,46 @@
+{
+  "workflowsDirectory": ".claude/workflows",
+  "autoLoadRules": true,
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/session-start.js"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/session-stop.js"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/user-prompt-submit.js"
+          }
+        ]
+      }
+    ]
+  },
+  "excludePatterns": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/lib/**",
+    "**/.git/**",
+    "**/coverage/**",
+    "**/.next/**",
+    "**/.nuxt/**"
+  ]
+}

package/dist/templates/docker/.env.lisa.example

@@ -0,0 +1,17 @@
+# Lisa Memory Settings
+# Copy this file to .env in your project root and fill in the values
+
+# OpenAI API key (required for entity extraction)
+OPENAI_API_KEY=sk-...
+
+# Neo4j credentials
+NEO4J_USER=neo4j
+NEO4J_PASSWORD=demodemo
+NEO4J_DATABASE=neo4j
+
+# Graphiti MCP
+# Group ID defaults to project name from package.json or directory name
+GRAPHITI_GROUP_ID=your-project-name
+GRAPHITI_ENDPOINT=http://localhost:8010/mcp/
+SEMAPHORE_LIMIT=10
+USE_PARALLEL_RUNTIME=false

package/dist/templates/docker/docker-compose.graphiti.yml

@@ -0,0 +1,45 @@
+name: lisa
+
+services:
+  neo4j:
+    image: neo4j:5.26.2
+    hostname: neo4j
+    ports:
+      - "7474:7474"
+      - "7687:7687"
+    environment:
+      - NEO4J_AUTH=${NEO4J_USER:-neo4j}/${NEO4J_PASSWORD:-demodemo}
+    volumes:
+      - neo4j_data:/data
+      - neo4j_logs:/logs
+    restart: always
+    healthcheck:
+      test: ["CMD-SHELL", "wget -qO- http://localhost:7474 || exit 1"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+      start_period: 15s
+
+  graphiti-mcp:
+    image: zepai/knowledge-graph-mcp:latest
+    depends_on:
+      neo4j:
+        condition: service_healthy
+    env_file:
+      - path: ../.env
+        required: false
+    environment:
+      # NEO4J_URI must point to container hostname, not localhost
+      - NEO4J_URI=bolt://neo4j:7687
+    ports:
+      - "8010:8000"
+    restart: always
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+
+volumes:
+  neo4j_data:
+  neo4j_logs:

package/dist/templates/rules/shared/clean-architecture.md

@@ -0,0 +1,333 @@
+# Clean Architecture Principles
+
+**Note:** These principles apply to ALL programming languages. See your language-specific rules for implementation details.
+
+## Overview
+
+Clean Architecture is a software design philosophy that emphasizes separation of concerns and dependency management. The core idea is to organize code into layers, with dependencies flowing inward toward the core business logic.
+
+## Layer Structure
+
+```
+src/
+├── domain/              # Core business entities and rules
+│   ├── entities/        # Business entities
+│   ├── errors/          # Domain-specific errors
+│   └── interfaces/      # Contracts (interfaces/protocols/traits)
+├── application/         # Business logic and use cases
+│   ├── interfaces/      # Application service contracts
+│   └── services/        # Use case implementations
+└── infrastructure/      # External concerns
+    ├── repositories/    # Data access implementations
+    └── services/        # External API integrations
+```
+
+## Layer Responsibilities
+
+### 1. Domain Layer (`src/domain/`)
+
+**Purpose:** Contains the core business rules and entities with zero dependencies on external frameworks or libraries.
+
+**What belongs here:**
+- Core business entities (Product, Order, User, etc.)
+- Business rules and validation logic
+- Domain errors and exceptions
+- Repository interfaces (contracts for data access)
+- Core service interfaces (business logic contracts)
+
+**Dependencies:** NONE - Domain depends on nothing else
+
+**Examples across languages:**
+- Entities: `Product`, `Order`, `Customer`
+- Interfaces: Repository contracts, service contracts
+- Errors: `ProductNotFoundError`, `InvalidOrderStateError`
+
+### 2. Application Layer (`src/application/`)
+
+**Purpose:** Orchestrates the domain layer and coordinates infrastructure to implement use cases.
+
+**What belongs here:**
+- Use case implementations
+- Application service interfaces
+- Application-specific logic
+- Coordination between domain and infrastructure
+
+**Dependencies:** Can depend on Domain layer ONLY
+
+**Examples:**
+- Services: `OrderService`, `CartService`, `CheckoutService`
+- Use cases: `CreateOrderUseCase`, `ProcessPaymentUseCase`
+- Configurations: `CheckoutConfig`, `PaymentConfig`
+
+### 3. Infrastructure Layer (`src/infrastructure/`)
+
+**Purpose:** Handles all interactions with external systems, databases, APIs, and frameworks.
+
+**What belongs here:**
+- Repository implementations (database access)
+- External API clients
+- Framework-specific code
+- Database connections
+- Third-party service integrations
+
+**Dependencies:** Can depend on both Application and Domain layers
+
+**Examples:**
+- Repositories: `ProductRepository`, `OrderRepository`
+- Services: `DatabaseService`, `PaymentGatewayService`
+- Clients: `EmailServiceClient`, `SMSServiceClient`
+
+## Dependency Rules
+
+### The Dependency Rule
+
+**Dependencies MUST point inward:**
+
+```
+Infrastructure → Application → Domain
+                              ↑
+                           Core Business
+```
+
+- **Domain** has NO dependencies
+- **Application** depends on Domain only
+- **Infrastructure** depends on Application and Domain
+
+### Why This Matters
+
+1. **Testability**: Domain can be tested without databases or external services
+2. **Flexibility**: Swap infrastructure without changing business logic
+3. **Maintainability**: Changes to external systems don't affect core business rules
+4. **Independence**: Business logic is independent of frameworks and tools
+
+## Dependency Inversion Principle
+
+The key to Clean Architecture is **Dependency Inversion**:
+
+- High-level modules should not depend on low-level modules
+- Both should depend on abstractions (interfaces/contracts)
+- Abstractions should not depend on details
+- Details should depend on abstractions
+
+### Example Flow
+
+```
+OrderService (Application)
+    ↓ depends on
+IOrderRepository (Domain interface)
+    ↑ implemented by
+OrderRepository (Infrastructure)
+```
+
+The service depends on the interface, not the implementation. The implementation depends on the interface.
+
+## Repository Pattern
+
+The Repository pattern mediates between the domain and data mapping layers.
+
+### Key Concepts
+
+1. **Interface in Domain**: Repository contracts live in domain layer
+2. **Implementation in Infrastructure**: Actual data access in infrastructure
+3. **Services use Interfaces**: Application services depend on interfaces, not implementations
+4. **Centralized Data Access**: All data operations go through repositories
+
+### Why Use Repositories
+
+- Decouples business logic from data storage
+- Makes testing easier (mock repositories)
+- Enables swapping data sources (SQL → NoSQL)
+- Centralizes data access patterns
+- Provides clear separation of concerns
+
+## Dependency Injection
+
+All dependencies should be injected, not instantiated.
+
+### Constructor Injection
+
+Dependencies are provided through the constructor, making them explicit and testable.
+
+**Benefits:**
+- Explicit dependencies
+- Easy to test (inject mocks)
+- Promotes loose coupling
+- Enables swapping implementations
+
+### Registration
+
+All services and repositories must be registered in a dependency injection container.
+
+**Location:** `src/infrastructure/di/`
+
+## SOLID Principles
+
+### Single Responsibility Principle (SRP)
+
+**Definition:** Each class should have only one reason to change.
+
+**Application:**
+- Each repository handles one entity
+- Each service handles one use case or related group
+- Keep classes focused and cohesive
+
+### Open/Closed Principle (OCP)
+
+**Definition:** Open for extension, closed for modification.
+
+**Application:**
+- Use interfaces to allow extension
+- Compose behavior rather than modifying existing code
+- Use dependency injection to swap implementations
+
+### Liskov Substitution Principle (LSP)
+
+**Definition:** Derived classes must be substitutable for their base classes.
+
+**Application:**
+- Implementations must honor interface contracts
+- No unexpected behavior in derived classes
+- Maintain consistent semantics
+
+### Interface Segregation Principle (ISP)
+
+**Definition:** Clients should not depend on interfaces they don't use.
+
+**Application:**
+- Create small, focused interfaces
+- Split large interfaces into smaller ones
+- Each interface should represent one capability
+
+### Dependency Inversion Principle (DIP)
+
+**Definition:** Depend on abstractions, not concretions.
+
+**Application:**
+- Services depend on repository interfaces
+- Use dependency injection
+- Infrastructure implements domain interfaces
+
+## Common Violations
+
+### ❌ Layer Violations
+
+**Problem:** Domain importing from infrastructure
+
+```
+// BAD - Domain importing infrastructure
+// In: src/domain/services/ProductService
+import { Database } from '../../infrastructure/database';
+```
+
+**Solution:** Domain should only define interfaces
+
+```
+// GOOD - Domain defines interface
+// In: src/domain/interfaces/
+export interface IDatabase { ... }
+
+// Infrastructure implements it
+// In: src/infrastructure/
+export class Database implements IDatabase { ... }
+```
+
+### ❌ Application Importing Infrastructure
+
+**Problem:** Application layer importing infrastructure implementations
+
+```
+// BAD - Application importing infrastructure
+// In: src/application/services/OrderService
+import { ProductRepository } from '../../infrastructure/repositories/ProductRepository';
+```
+
+**Solution:** Application should depend on domain interfaces
+
+```
+// GOOD - Application depends on interface
+// In: src/application/services/OrderService
+import { IProductRepository } from '../../domain/interfaces/IProductRepository';
+
+// Infrastructure is injected via DI
+constructor(private readonly productRepo: IProductRepository) {}
+```
+
+### ❌ Direct Database Access in Services
+
+**Problem:** Services accessing database directly
+
+**Solution:** Always use repository abstractions
+
+### ❌ Business Logic in Infrastructure
+
+**Problem:** Business rules in repository implementations
+
+**Solution:** Keep repositories focused on data access, move logic to domain/application
+
+## Testing Strategy
+
+### Domain Layer Tests
+
+- Test business logic in isolation
+- No mocking needed (pure logic)
+- Fast, deterministic tests
+
+### Application Layer Tests
+
+- Mock repository interfaces
+- Test use case orchestration
+- Verify correct repository calls
+
+### Infrastructure Layer Tests
+
+- Integration tests with real dependencies
+- Test data access patterns
+- Verify error handling
+
+## Benefits of Clean Architecture
+
+1. **Independent of Frameworks**: Business rules don't depend on external libraries
+2. **Testable**: Business logic can be tested without UI, database, or external services
+3. **Independent of UI**: Can change UI without changing business rules
+4. **Independent of Database**: Can swap databases without changing business logic
+5. **Independent of External Services**: Business rules don't know about external APIs
+
+## Migration Path
+
+### Legacy Code
+
+If you have existing code that doesn't follow Clean Architecture:
+
+1. Start with new features following the pattern
+2. Gradually extract interfaces from existing code
+3. Move business logic to domain/application
+4. Create repository interfaces for data access
+5. Refactor incrementally, don't rewrite everything
+
+### Red Flags
+
+- Circular dependencies
+- Business logic in infrastructure
+- Direct database access in services
+- Framework coupling in domain
+- God classes (too many responsibilities)
+
+## Language-Specific Details
+
+For language-specific implementation details (naming conventions, syntax, idioms), see your language-specific rules:
+
+- **TypeScript**: `languages/typescript/coding-standards.md`
+- **Python**: `languages/python/coding-standards.md`
+- **Go**: `languages/go/coding-standards.md`
+- **Java**: `languages/java/coding-standards.md`
+
+## Summary Checklist
+
+- [ ] Domain layer has no dependencies
+- [ ] Application layer depends on domain only
+- [ ] Infrastructure implements domain interfaces
+- [ ] All data access through repositories
+- [ ] Dependencies injected, not instantiated
+- [ ] Each class has single responsibility
+- [ ] Interfaces are small and focused
+- [ ] Business logic is testable in isolation