cognitive-core 0.1.0 → 0.2.0

package/references/minimem/claude-plugin/hooks/session-start.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+# minimem SessionStart hook
+# Injects recent relevant memories into the session context.
+# Runs on session startup and resume.
+
+set -euo pipefail
+
+# Read hook input from stdin
+INPUT=$(cat)
+
+# Only proceed if minimem is initialized (local or global)
+HAS_LOCAL=""
+HAS_GLOBAL=""
+if [ -d ".minimem" ]; then
+  HAS_LOCAL="1"
+fi
+if [ -d "$HOME/.minimem" ]; then
+  HAS_GLOBAL="1"
+fi
+
+if [ -z "$HAS_LOCAL" ] && [ -z "$HAS_GLOBAL" ]; then
+  exit 0
+fi
+
+# Check config to see if this hook is enabled (defaults to true)
+HOOK_ENABLED=$(node -e "
+  const fs = require('fs');
+  const path = require('path');
+  const configs = [];
+  try { configs.push(JSON.parse(fs.readFileSync(path.join(process.env.HOME, '.minimem', '.minimem', 'config.json'), 'utf-8'))); } catch {}
+  try { configs.push(JSON.parse(fs.readFileSync('.minimem/config.json', 'utf-8'))); } catch {}
+  // Last config wins (local overrides global)
+  for (const c of configs.reverse()) {
+    if (c.hooks && typeof c.hooks.sessionStart === 'boolean') {
+      console.log(c.hooks.sessionStart ? 'true' : 'false');
+      process.exit(0);
+    }
+  }
+  console.log('false');
+" 2>/dev/null) || echo "false"
+
+if [ "$HOOK_ENABLED" = "false" ]; then
+  exit 0
+fi
+
+# Build search args
+SEARCH_ARGS=("search" "recent context session" "--max-results" "5" "--json")
+if [ -n "$HAS_LOCAL" ]; then
+  SEARCH_ARGS+=("--dir" ".")
+fi
+if [ -n "$HAS_GLOBAL" ]; then
+  SEARCH_ARGS+=("--global")
+fi
+
+# Run search (suppress errors — don't block session start)
+RESULTS=$(npx --yes minimem "${SEARCH_ARGS[@]}" 2>/dev/null) || true
+
+if [ -z "$RESULTS" ] || [ "$RESULTS" = "[]" ] || [ "$RESULTS" = "null" ]; then
+  exit 0
+fi
+
+# Format as context for Claude
+CONTEXT="## Recent Memory Context (from minimem)\n\n"
+CONTEXT+=$(echo "$RESULTS" | node -e "
+  const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf-8'));
+  if (!Array.isArray(data) || data.length === 0) process.exit(0);
+  data.slice(0, 5).forEach((r, i) => {
+    const loc = r.path + ':' + r.startLine + '-' + r.endLine;
+    const score = (r.score * 100).toFixed(0);
+    const preview = r.snippet.split('\n')[0].slice(0, 80);
+    console.log('[' + i + '] ' + loc + ' (' + score + '%) — ' + preview);
+  });
+" 2>/dev/null) || true
+
+if [ -z "$CONTEXT" ]; then
+  exit 0
+fi
+
+# Output as JSON with additionalContext for Claude to see
+echo "{\"additionalContext\": $(echo -e "$CONTEXT" | node -e "
+  const text = require('fs').readFileSync('/dev/stdin', 'utf-8');
+  process.stdout.write(JSON.stringify(text));
+" 2>/dev/null)}"
+
+exit 0

package/references/minimem/claude-plugin/skills/memory/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: memory
+description: Search and manage memories using minimem. Use when the user wants to recall previous context, decisions, notes, or stored information. Also use when storing new information for later retrieval.
+---
+
+# Memory Skill
+
+Use the minimem memory system to store and retrieve persistent context.
+
+## When to Use This Skill
+
+- User asks to "remember" or "store" something
+- User asks to "recall", "find", or "search for" previous context
+- User references past decisions, notes, or information
+- You need to persist information across sessions
+- User mentions "memory" or "memories"
+
+## Available MCP Tools
+
+### memory_search (two-phase search)
+
+```
+memory_search(query, maxResults?, minScore?, directories?, detail?, type?)
+```
+
+- `query`: Natural language search query
+- `maxResults`: Maximum results (default: 10)
+- `minScore`: Minimum relevance 0-1 (default: 0.3)
+- `directories`: Filter to specific memory directories
+- `detail`: `"compact"` (default) for lightweight index, `"full"` for complete snippets
+- `type`: Filter by observation type (decision, bugfix, feature, discovery, context, note)
+
+### memory_get_details
+
+```
+memory_get_details(results, directories?)
+```
+
+- `results`: Array of `{ path, startLine, endLine }` from compact search results
+- `directories`: Filter to specific memory directories
+
+## Searching Memories (Two-Phase Workflow)
+
+When the user wants to recall information:
+
+1. Use `memory_search` with a descriptive query (defaults to compact results)
+2. Review the compact index — each result shows path, score, and short preview
+3. Use `memory_get_details` to fetch full text for the most relevant results
+4. Synthesize and present the information, citing source files
+
+This two-phase approach saves tokens by only fetching details for results that matter.
+
+For quick lookups where you need all details immediately, use `detail: "full"`.
+
+### Filtering by Type
+
+Use the `type` parameter to narrow results:
+- `memory_search(query: "API design", type: "decision")` — only decisions
+- `memory_search(query: "login bug", type: "bugfix")` — only bug fixes
+
+## Storing Memories
+
+To store new information, use filesystem tools to write to memory files:
+
+1. **Quick notes** → Append to `memory/YYYY-MM-DD.md` (today's date)
+2. **Decisions** → Add to `MEMORY.md` under appropriate heading
+3. **Topic-specific** → Create/update `memory/<topic>.md`
+
+### Storage Format
+
+```markdown
+### YYYY-MM-DD HH:MM
+<!-- type: decision -->
+<content to remember>
+```
+
+### Observation Types
+
+Add a type comment to categorize entries for filtered search:
+
+- `<!-- type: decision -->` — architectural or design decisions
+- `<!-- type: bugfix -->` — bug fixes and root causes
+- `<!-- type: feature -->` — new feature implementations
+- `<!-- type: discovery -->` — learned facts, insights
+- `<!-- type: context -->` — project context, setup notes
+- `<!-- type: note -->` — general notes (default)
+
+### Privacy
+
+Wrap sensitive content in `<private>` tags to exclude it from search indexing:
+
+```markdown
+API endpoint: api.example.com/v2
+
+<private>
+API_KEY=sk-abc123
+DB_PASSWORD=hunter2
+</private>
+```
+
+## Best Practices
+
+1. Use specific, searchable terms when storing
+2. Include context: dates, people, project names
+3. Add type comments for important entries (decisions, bugfixes)
+4. Use `<private>` tags for credentials and secrets
+5. Start with compact search, then fetch details as needed
+6. When searching, try multiple query variations if needed