@claudetools/tools 0.2.1 → 0.3.0

package/dist/cli.js

@@ -7,7 +7,7 @@ import { parseArgs } from 'node:util';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { runSetup, runUninstall } from './setup.js';
+import { runSetup, runUninstall, runInit } from './setup.js';
 import { startServer } from './index.js';
 import { startWatcher, stopWatcher, watcherStatus } from './watcher.js';
 // Get version from package.json
@@ -47,6 +47,7 @@ Options:
   -h, --help       Show this help
 
 Commands:
+  init             Initialize current directory as a project
   watch            Start the file watcher daemon
   watch --stop     Stop the watcher daemon
   watch --status   Check watcher status
@@ -70,6 +71,13 @@ else if (values.uninstall) {
         process.exit(1);
     });
 }
+else if (positionals[0] === 'init') {
+    // Handle init command
+    runInit().catch((error) => {
+        console.error('Init failed:', error);
+        process.exit(1);
+    });
+}
 else if (positionals[0] === 'watch') {
     // Handle watch command
     const watchArgs = process.argv.slice(3); // Get args after 'watch'

package/dist/helpers/project-registration.js

@@ -85,15 +85,21 @@ async function ensureSystemRegistered() {
  */
 function detectGitRemote(localPath) {
     try {
+        // Resolve symlinks and validate path to prevent path traversal attacks
+        const resolvedPath = fs.realpathSync(localPath);
+        // Ensure path is absolute and doesn't contain path traversal
+        if (!path.isAbsolute(resolvedPath) || resolvedPath.includes('..')) {
+            return undefined;
+        }
         const gitRemote = execSync('git config --get remote.origin.url', {
-            cwd: localPath,
+            cwd: resolvedPath,
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'ignore'],
         }).trim();
         return gitRemote || undefined;
     }
     catch {
-        // Not a git repo or no remote configured
+        // Not a git repo, no remote configured, or invalid path
         return undefined;
     }
 }

package/dist/setup.d.ts

@@ -1,2 +1,3 @@
 export declare function runSetup(): Promise<void>;
 export declare function runUninstall(): Promise<void>;
+export declare function runInit(): Promise<void>;

package/dist/setup.js

@@ -10,6 +10,7 @@ import { join, basename } from 'path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from 'fs';
 import { randomUUID } from 'crypto';
 import { loadConfigFromFile, saveConfig, ensureConfigDir, getConfigPath, DEFAULT_CONFIG, } from './helpers/config-manager.js';
+import { GLOBAL_TEMPLATE, SECTION_START, SECTION_END, getProjectTemplate, } from './templates/claude-md.js';
 // -----------------------------------------------------------------------------
 // Constants
 // -----------------------------------------------------------------------------
@@ -18,6 +19,7 @@ const CLAUDETOOLS_DIR = join(homedir(), '.claudetools');
 const MCP_CONFIG_PATH = join(CLAUDE_DIR, 'mcp.json');
 const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
 const HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
+const CLAUDE_MD_PATH = join(CLAUDE_DIR, 'CLAUDE.md');
 const SYSTEM_FILE = join(CLAUDETOOLS_DIR, 'system.json');
 const PROJECTS_FILE = join(CLAUDETOOLS_DIR, 'projects.json');
 // -----------------------------------------------------------------------------
@@ -455,26 +457,111 @@ async function installHooks() {
     // Session start hook - ensures watcher is running
     const sessionStartHook = `#!/bin/bash
 # ClaudeTools Session Start Hook
-# Ensures the code watcher is running when Claude Code starts
+# 1. Ensures the code watcher is running
+# 2. Fetches and injects project context for the session
 
 # Skip if disabled
 if [ "$CLAUDE_DISABLE_HOOKS" = "1" ]; then exit 0; fi
 
-# Check if watcher is already running
+CONFIG_FILE="$HOME/.claudetools/config.json"
+CONTEXT_FILE="$HOME/.claudetools/session-context.md"
+PROJECTS_FILE="$HOME/.claudetools/projects.json"
 WATCHER_PID_FILE="/tmp/claudetools-watcher.pid"
+
+# --- Watcher Management ---
+
+# Check if watcher is already running
 if [ -f "$WATCHER_PID_FILE" ]; then
   PID=$(cat "$WATCHER_PID_FILE")
-  if kill -0 "$PID" 2>/dev/null; then
-    # Watcher is running
-    exit 0
+  if ! kill -0 "$PID" 2>/dev/null; then
+    # PID file exists but process is dead, clean up
+    rm -f "$WATCHER_PID_FILE"
   fi
 fi
 
-# Start watcher in background if claudetools is installed
-if command -v claudetools &> /dev/null; then
+# Start watcher in background if not running
+if [ ! -f "$WATCHER_PID_FILE" ] && command -v claudetools &> /dev/null; then
   nohup claudetools watch > /tmp/claudetools-watcher.log 2>&1 &
   echo $! > "$WATCHER_PID_FILE"
 fi
+
+# --- Context Injection ---
+
+# Read config
+if [ ! -f "$CONFIG_FILE" ]; then exit 0; fi
+
+API_URL=$(jq -r '.apiUrl // "https://api.claudetools.dev"' "$CONFIG_FILE" 2>/dev/null)
+API_KEY=$(jq -r '.apiKey // empty' "$CONFIG_FILE" 2>/dev/null)
+
+if [ -z "$API_KEY" ]; then exit 0; fi
+
+# Get current project from working directory
+CWD=$(pwd)
+PROJECT_ID=""
+PROJECT_NAME=""
+
+if [ -f "$PROJECTS_FILE" ]; then
+  # Find project by path prefix match
+  PROJECT_DATA=$(jq -r --arg cwd "$CWD" '
+    .bindings[]? | select(.local_path != null) |
+    select($cwd | startswith(.local_path)) |
+    {project_id, project_name}' "$PROJECTS_FILE" 2>/dev/null | head -1)
+
+  if [ -n "$PROJECT_DATA" ]; then
+    PROJECT_ID=$(echo "$PROJECT_DATA" | jq -r '.project_id // empty')
+    PROJECT_NAME=$(echo "$PROJECT_DATA" | jq -r '.project_name // empty')
+  fi
+fi
+
+# If no project found, use directory name
+if [ -z "$PROJECT_NAME" ]; then
+  PROJECT_NAME=$(basename "$CWD")
+fi
+
+# Fetch context from API (with 2s timeout)
+if [ -n "$PROJECT_ID" ]; then
+  CONTEXT=$(curl -s --max-time 2 -X POST "$API_URL/api/v1/context/session" \\
+    -H "Authorization: Bearer $API_KEY" \\
+    -H "Content-Type: application/json" \\
+    -d "{\\"project_id\\": \\"$PROJECT_ID\\"}" 2>/dev/null)
+
+  if [ -n "$CONTEXT" ] && [ "$CONTEXT" != "null" ]; then
+    # Extract facts and patterns from response
+    FACTS=$(echo "$CONTEXT" | jq -r '.facts // []' 2>/dev/null)
+    PATTERNS=$(echo "$CONTEXT" | jq -r '.patterns // []' 2>/dev/null)
+
+    # Generate session context file
+    cat > "$CONTEXT_FILE" << CTXEOF
+# Session Context: $PROJECT_NAME
+
+**Project ID:** $PROJECT_ID
+**Generated:** $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+## Relevant Facts
+
+$(echo "$FACTS" | jq -r '.[] | "- \\(.entity1) \\(.relationship) \\(.entity2): \\(.context)"' 2>/dev/null || echo "- No facts stored yet")
+
+## Detected Patterns
+
+$(echo "$PATTERNS" | jq -r '.[] | "- **\\(.name)**: \\(.description)"' 2>/dev/null || echo "- No patterns detected yet")
+
+---
+*This file is regenerated each session. Do not edit manually.*
+CTXEOF
+  fi
+else
+  # No project registered, create minimal context file
+  cat > "$CONTEXT_FILE" << CTXEOF
+# Session Context: $PROJECT_NAME
+
+**Status:** Project not registered with ClaudeTools
+
+Run \\\`claudetools init\\\` in this directory to register the project and enable memory features.
+
+---
+*This file is regenerated each session.*
+CTXEOF
+fi
 `;
     const sessionStartPath = join(HOOKS_DIR, 'session-start.sh');
     if (existsSync(sessionStartPath)) {
@@ -662,6 +749,83 @@ async function configureSettings() {
     success(`Saved settings to ${SETTINGS_PATH}`);
 }
 // -----------------------------------------------------------------------------
+// CLAUDE.md Configuration
+// -----------------------------------------------------------------------------
+async function configureCLAUDEMD() {
+    header('CLAUDE.md Configuration');
+    ensureClaudeDir();
+    // Check if CLAUDE.md exists
+    let existingContent = '';
+    if (existsSync(CLAUDE_MD_PATH)) {
+        existingContent = readFileSync(CLAUDE_MD_PATH, 'utf-8');
+        // Check if claudetools section already exists
+        if (existingContent.includes(SECTION_START)) {
+            info('ClaudeTools section already exists in CLAUDE.md');
+            const { update } = await prompts({
+                type: 'confirm',
+                name: 'update',
+                message: 'Update existing ClaudeTools section?',
+                initial: true,
+            });
+            if (update) {
+                // Remove existing section
+                const startIdx = existingContent.indexOf(SECTION_START);
+                const endIdx = existingContent.indexOf(SECTION_END);
+                if (startIdx !== -1 && endIdx !== -1) {
+                    existingContent =
+                        existingContent.slice(0, startIdx).trimEnd() +
+                            '\n' +
+                            existingContent.slice(endIdx + SECTION_END.length).trimStart();
+                }
+            }
+            else {
+                return;
+            }
+        }
+        // Backup existing file
+        const backup = backupFile(CLAUDE_MD_PATH);
+        if (backup) {
+            info(`Backed up existing CLAUDE.md to ${basename(backup)}`);
+        }
+    }
+    // Append claudetools section
+    const newContent = existingContent.trimEnd() + '\n' + GLOBAL_TEMPLATE;
+    writeFileSync(CLAUDE_MD_PATH, newContent);
+    success('Added ClaudeTools section to CLAUDE.md');
+}
+function removeCLAUDEMDSection() {
+    if (!existsSync(CLAUDE_MD_PATH)) {
+        return;
+    }
+    try {
+        let content = readFileSync(CLAUDE_MD_PATH, 'utf-8');
+        if (!content.includes(SECTION_START)) {
+            return;
+        }
+        const startIdx = content.indexOf(SECTION_START);
+        const endIdx = content.indexOf(SECTION_END);
+        if (startIdx !== -1 && endIdx !== -1) {
+            content =
+                content.slice(0, startIdx).trimEnd() +
+                    '\n' +
+                    content.slice(endIdx + SECTION_END.length).trimStart();
+            // If content is now empty (only whitespace), remove the file
+            if (content.trim() === '') {
+                const { unlinkSync } = require('fs');
+                unlinkSync(CLAUDE_MD_PATH);
+                success('Removed CLAUDE.md (was only claudetools content)');
+            }
+            else {
+                writeFileSync(CLAUDE_MD_PATH, content.trim() + '\n');
+                success('Removed ClaudeTools section from CLAUDE.md');
+            }
+        }
+    }
+    catch {
+        error('Could not update CLAUDE.md');
+    }
+}
+// -----------------------------------------------------------------------------
 // Verification
 // -----------------------------------------------------------------------------
 async function verifySetup(config) {
@@ -712,6 +876,19 @@ async function verifySetup(config) {
     else {
         error('Settings not found');
     }
+    // Check CLAUDE.md configured
+    if (existsSync(CLAUDE_MD_PATH)) {
+        const content = readFileSync(CLAUDE_MD_PATH, 'utf-8');
+        if (content.includes(SECTION_START)) {
+            success('CLAUDE.md configured');
+        }
+        else {
+            error('CLAUDE.md missing ClaudeTools section');
+        }
+    }
+    else {
+        error('CLAUDE.md not found');
+    }
 }
 // -----------------------------------------------------------------------------
 // Main Setup Flow
@@ -728,7 +905,7 @@ export async function runSetup() {
         // Step 1: Authentication
         header('Authentication');
         if (config.apiKey) {
-            info(`Existing API key found: ${config.apiKey.substring(0, 10)}...`);
+            info(`Existing API key found: ${config.apiKey.substring(0, 6)}...`);
             const { replace } = await prompts({
                 type: 'confirm',
                 name: 'replace',
@@ -801,7 +978,9 @@ export async function runSetup() {
         await installHooks();
         // Step 8: Configure Settings
         await configureSettings();
-        // Step 9: Verify
+        // Step 9: Configure CLAUDE.md
+        await configureCLAUDEMD();
+        // Step 10: Verify
         await verifySetup(extendedConfig);
         // Done
         header('Setup Complete');
@@ -889,6 +1068,128 @@ export async function runUninstall() {
             // Process might already be dead
         }
     }
+    // Remove CLAUDE.md section
+    removeCLAUDEMDSection();
     console.log('\n' + chalk.green('ClaudeTools removed from Claude Code.'));
     console.log(chalk.dim('Your ~/.claudetools/ config and data are preserved.\n'));
 }
+// -----------------------------------------------------------------------------
+// Project Init
+// -----------------------------------------------------------------------------
+export async function runInit() {
+    console.log('\n' + chalk.bold.cyan('  ClaudeTools Project Init') + '\n');
+    const cwd = process.cwd();
+    const projectName = basename(cwd);
+    const projectClaudeDir = join(cwd, '.claude');
+    const projectClaudeMd = join(projectClaudeDir, 'CLAUDE.md');
+    // Check if config exists
+    const config = await loadConfigFromFile();
+    if (!config?.apiKey) {
+        error('ClaudeTools not configured. Run "claudetools --setup" first.');
+        process.exit(1);
+    }
+    // Try to register project with API
+    const spinner = ora('Registering project...').start();
+    let projectId;
+    try {
+        const response = await fetch(`${config.apiUrl || DEFAULT_CONFIG.apiUrl}/api/v1/projects/register`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.apiKey}`,
+            },
+            body: JSON.stringify({
+                name: projectName,
+                local_path: cwd,
+            }),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            projectId = data.project_id;
+            spinner.succeed(`Registered project: ${projectId}`);
+            // Update local projects.json
+            try {
+                const projectsData = existsSync(PROJECTS_FILE)
+                    ? JSON.parse(readFileSync(PROJECTS_FILE, 'utf-8'))
+                    : { bindings: [] };
+                // Check if already in bindings
+                const existingIdx = projectsData.bindings.findIndex((b) => b.local_path === cwd);
+                if (existingIdx >= 0) {
+                    projectsData.bindings[existingIdx].project_id = projectId;
+                }
+                else {
+                    projectsData.bindings.push({
+                        project_id: projectId,
+                        local_path: cwd,
+                        project_name: projectName,
+                        cached_at: new Date().toISOString(),
+                    });
+                }
+                projectsData.last_sync = new Date().toISOString();
+                writeFileSync(PROJECTS_FILE, JSON.stringify(projectsData, null, 2));
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        else {
+            spinner.warn('Could not register with API, using local ID');
+            projectId = `local_${projectName.toLowerCase().replace(/[^a-z0-9]/g, '_')}`;
+        }
+    }
+    catch {
+        spinner.warn('Could not reach API, using local ID');
+        projectId = `local_${projectName.toLowerCase().replace(/[^a-z0-9]/g, '_')}`;
+    }
+    // Create .claude directory if needed
+    if (!existsSync(projectClaudeDir)) {
+        mkdirSync(projectClaudeDir, { recursive: true });
+        success('Created .claude/ directory');
+    }
+    // Create or update CLAUDE.md
+    let existingContent = '';
+    if (existsSync(projectClaudeMd)) {
+        existingContent = readFileSync(projectClaudeMd, 'utf-8');
+        // Check if claudetools section already exists
+        if (existingContent.includes(SECTION_START)) {
+            info('ClaudeTools section already exists');
+            const { update } = await prompts({
+                type: 'confirm',
+                name: 'update',
+                message: 'Update existing ClaudeTools section?',
+                initial: true,
+            });
+            if (update) {
+                // Remove existing section
+                const startIdx = existingContent.indexOf(SECTION_START);
+                const endIdx = existingContent.indexOf(SECTION_END);
+                if (startIdx !== -1 && endIdx !== -1) {
+                    existingContent =
+                        existingContent.slice(0, startIdx).trimEnd() +
+                            '\n' +
+                            existingContent.slice(endIdx + SECTION_END.length).trimStart();
+                }
+            }
+            else {
+                console.log('\n' + chalk.green('Project already initialized.'));
+                return;
+            }
+        }
+        // Backup existing file
+        const backup = backupFile(projectClaudeMd);
+        if (backup) {
+            info(`Backed up existing CLAUDE.md to ${basename(backup)}`);
+        }
+    }
+    // Write project CLAUDE.md
+    const projectContent = getProjectTemplate(projectId, projectName);
+    const newContent = existingContent.trimEnd() + '\n' + projectContent;
+    writeFileSync(projectClaudeMd, newContent);
+    success('Created .claude/CLAUDE.md');
+    // Summary
+    console.log('\n' + chalk.green('  Project initialized!\n'));
+    console.log('  ' + chalk.bold('Project:') + ` ${projectName}`);
+    console.log('  ' + chalk.bold('ID:') + ` ${projectId}`);
+    console.log('  ' + chalk.bold('Config:') + ` ${projectClaudeMd}\n`);
+    console.log(chalk.dim('  Memory tools are now configured for this project.\n'));
+}

package/dist/templates/claude-md.d.ts

@@ -0,0 +1,24 @@
+export declare const SECTION_START = "<!-- CLAUDETOOLS:START -->";
+export declare const SECTION_END = "<!-- CLAUDETOOLS:END -->";
+export declare const PROJECT_SECTION_START = "<!-- CLAUDETOOLS:PROJECT:START -->";
+export declare const PROJECT_SECTION_END = "<!-- CLAUDETOOLS:PROJECT:END -->";
+/**
+ * Global CLAUDE.md content - added to ~/.claude/CLAUDE.md
+ */
+export declare const GLOBAL_TEMPLATE = "\n<!-- CLAUDETOOLS:START -->\n# ClaudeTools Memory System\n\nYou have access to a persistent memory system via the `claudetools_memory` MCP server. Use it to remember context across sessions.\n\n## Memory Tools\n\n### Searching Memory\n```\nmemory_search(query: \"authentication patterns\")\n```\nSearch for relevant facts, entities, and past context. Use this when:\n- Starting work on a feature to recall past decisions\n- Looking for patterns or conventions used before\n- Finding related code or architectural context\n\n### Storing Facts\n```\nmemory_store_fact(\n  entity1: \"UserService\",\n  relationship: \"USES\",\n  entity2: \"bcrypt\",\n  context: \"Password hashing uses bcrypt with 12 rounds\"\n)\n```\nStore important facts as relationships between entities. Use for:\n- Architectural decisions\n- Code patterns and conventions\n- Dependencies and relationships\n- User preferences learned during conversation\n\n### Context Injection\nContext is automatically injected at the start of each session based on the current project. Check `~/.claudetools/session-context.md` for project-specific context.\n\n## Task Management\n\n### Creating Work Plans\n```\ntask_plan(\n  goal: \"Add user authentication\",\n  epic_title: \"User Auth System\",\n  tasks: [...]\n)\n```\nBreak down complex work into tracked tasks.\n\n### Starting Tasks\n```\ntask_start(task_id: \"task_xxx\")\n```\nClaim a task before working on it.\n\n### Completing Tasks\n```\ntask_complete(task_id: \"task_xxx\", summary: \"Implemented JWT auth with refresh tokens\")\n```\nMark tasks done with a summary of work completed.\n\n## Codebase Intelligence\n\n### Finding Code\n```\ncodebase_map()           # Get overview of project structure\ncodebase_find(\"UserService\")  # Find symbols/files\ncodebase_context(\"src/auth.ts\")  # Get file dependencies\n```\n\n### Impact Analysis\n```\nanalyze_impact(function_name: \"validateToken\")\n```\nSee what would be affected by changing a function.\n\n## Best Practices\n\n1. **Search before implementing** - Check memory for existing patterns\n2. **Store decisions** - Save architectural choices as facts\n3. **Use task tracking** - Break complex work into tasks\n4. **Complete tasks** - Always mark tasks done with summaries\n<!-- CLAUDETOOLS:END -->\n";
+/**
+ * Project-level CLAUDE.md content - added to .claude/CLAUDE.md
+ */
+export declare function getProjectTemplate(projectId: string, projectName: string): string;
+/**
+ * Session context template - written to ~/.claudetools/session-context.md
+ */
+export declare function getSessionContextTemplate(projectName: string, projectId: string, facts: Array<{
+    entity1: string;
+    relationship: string;
+    entity2: string;
+    context: string;
+}>, patterns: Array<{
+    name: string;
+    description: string;
+}>): string;

package/dist/templates/claude-md.js

@@ -0,0 +1,157 @@
+// =============================================================================
+// CLAUDE.md Template Content
+// =============================================================================
+// Templates for global and project-level CLAUDE.md integration
+// Markers for identifying claudetools sections
+export const SECTION_START = '<!-- CLAUDETOOLS:START -->';
+export const SECTION_END = '<!-- CLAUDETOOLS:END -->';
+export const PROJECT_SECTION_START = '<!-- CLAUDETOOLS:PROJECT:START -->';
+export const PROJECT_SECTION_END = '<!-- CLAUDETOOLS:PROJECT:END -->';
+/**
+ * Global CLAUDE.md content - added to ~/.claude/CLAUDE.md
+ */
+export const GLOBAL_TEMPLATE = `
+${SECTION_START}
+# ClaudeTools Memory System
+
+You have access to a persistent memory system via the \`claudetools_memory\` MCP server. Use it to remember context across sessions.
+
+## Memory Tools
+
+### Searching Memory
+\`\`\`
+memory_search(query: "authentication patterns")
+\`\`\`
+Search for relevant facts, entities, and past context. Use this when:
+- Starting work on a feature to recall past decisions
+- Looking for patterns or conventions used before
+- Finding related code or architectural context
+
+### Storing Facts
+\`\`\`
+memory_store_fact(
+  entity1: "UserService",
+  relationship: "USES",
+  entity2: "bcrypt",
+  context: "Password hashing uses bcrypt with 12 rounds"
+)
+\`\`\`
+Store important facts as relationships between entities. Use for:
+- Architectural decisions
+- Code patterns and conventions
+- Dependencies and relationships
+- User preferences learned during conversation
+
+### Context Injection
+Context is automatically injected at the start of each session based on the current project. Check \`~/.claudetools/session-context.md\` for project-specific context.
+
+## Task Management
+
+### Creating Work Plans
+\`\`\`
+task_plan(
+  goal: "Add user authentication",
+  epic_title: "User Auth System",
+  tasks: [...]
+)
+\`\`\`
+Break down complex work into tracked tasks.
+
+### Starting Tasks
+\`\`\`
+task_start(task_id: "task_xxx")
+\`\`\`
+Claim a task before working on it.
+
+### Completing Tasks
+\`\`\`
+task_complete(task_id: "task_xxx", summary: "Implemented JWT auth with refresh tokens")
+\`\`\`
+Mark tasks done with a summary of work completed.
+
+## Codebase Intelligence
+
+### Finding Code
+\`\`\`
+codebase_map()           # Get overview of project structure
+codebase_find("UserService")  # Find symbols/files
+codebase_context("src/auth.ts")  # Get file dependencies
+\`\`\`
+
+### Impact Analysis
+\`\`\`
+analyze_impact(function_name: "validateToken")
+\`\`\`
+See what would be affected by changing a function.
+
+## Best Practices
+
+1. **Search before implementing** - Check memory for existing patterns
+2. **Store decisions** - Save architectural choices as facts
+3. **Use task tracking** - Break complex work into tasks
+4. **Complete tasks** - Always mark tasks done with summaries
+${SECTION_END}
+`;
+/**
+ * Project-level CLAUDE.md content - added to .claude/CLAUDE.md
+ */
+export function getProjectTemplate(projectId, projectName) {
+    return `
+${SECTION_START}
+# Project: ${projectName}
+
+This project is registered with ClaudeTools Memory.
+
+**Project ID:** \`${projectId}\`
+
+## Project Memory
+
+Use memory tools to search and store project-specific context:
+
+\`\`\`
+# Search this project's memory
+memory_search(query: "your search", project_id: "${projectId}")
+
+# Store a project fact
+memory_store_fact(
+  entity1: "ComponentName",
+  relationship: "IMPLEMENTS",
+  entity2: "PatternName",
+  context: "Description of the relationship",
+  project_id: "${projectId}"
+)
+\`\`\`
+
+## Session Context
+
+Project-specific context is injected automatically. Check \`~/.claudetools/session-context.md\` for current context.
+${SECTION_END}
+`;
+}
+/**
+ * Session context template - written to ~/.claudetools/session-context.md
+ */
+export function getSessionContextTemplate(projectName, projectId, facts, patterns) {
+    const factsList = facts.length > 0
+        ? facts.map(f => `- ${f.entity1} ${f.relationship} ${f.entity2}: ${f.context}`).join('\n')
+        : '- No facts stored yet';
+    const patternsList = patterns.length > 0
+        ? patterns.map(p => `- **${p.name}**: ${p.description}`).join('\n')
+        : '- No patterns detected yet';
+    return `# Session Context: ${projectName}
+
+**Project ID:** ${projectId}
+**Generated:** ${new Date().toISOString()}
+
+## Relevant Facts
+
+${factsList}
+
+## Detected Patterns
+
+${patternsList}
+
+---
+*This file is regenerated each session. Do not edit manually.*
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudetools/tools",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",