claude-recall 0.36.0 → 0.36.1

package/README.md

@@ -211,6 +211,7 @@ claude-recall search "preference"
 claude-recall status                     # Installation health: hooks, MCP, DB path, project ID
 claude-recall stats                      # What's in the DB for this project (--global for all)
 
+claude-recall list                       # List all memories, newest first (-t <type>, --all, --json, --global)
 claude-recall search "query"             # Search this project's memories (--global, --json, --project <id>)
 claude-recall failures                   # What broke and what fixed it
 claude-recall outcomes                   # Outcome-aware learning status
@@ -273,6 +274,7 @@ claude-recall hooks test-enforcement     # Test if search enforcer hook works
 
 # ── Memory ───────────────────────────────────────────────────────────
 claude-recall stats                      # Memory statistics (--global for all projects)
+claude-recall list                       # List memories, newest first (-t <type>, --all, --json, --global)
 claude-recall search "query"             # Search memories (--global, --json, --project <id>)
 claude-recall store "content"            # Store memory directly
 claude-recall store "content" -t <type>  # Type: preference, correction, failure, devops, project-knowledge

package/dist/cli/claude-recall-cli.js

@@ -733,6 +733,85 @@ class ClaudeRecallCLI {
         });
         this.logger.info('CLI', 'Search completed', { query, resultCount: results.length });
     }
+    /**
+     * List (enumerate) stored memories — no query, no ranking, no relevance cap.
+     *
+     * Fills the gap between `search` (needs a query, returns ranked top-N) and
+     * `stats` (counts only, no content). Backed by getAllByProject/getAllMemories
+     * so it returns EVERYTHING in scope, newest first. Shows the numeric id and
+     * key so rows can be fed to `delete <key>` / `rules promote <id>`.
+     */
+    listMemories(options) {
+        // Scope resolution mirrors search(): current project (+ universal/unscoped)
+        // by default, a named project, or every project with --global.
+        let memories;
+        let scopeLabel;
+        if (options.global) {
+            memories = this.memoryService.getAllMemories();
+            scopeLabel = 'all projects';
+        }
+        else {
+            const projectId = options.project || config_1.ConfigService.getInstance().getProjectId();
+            memories = this.memoryService.getAllByProject(projectId);
+            scopeLabel = `project: ${projectId}`;
+        }
+        if (options.type) {
+            memories = memories.filter(m => m.type === options.type);
+        }
+        // Newest first — most recently learned memory at the top.
+        memories.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+        const total = memories.length;
+        const limit = options.all ? total : (0, parse_utils_1.parsePositiveInt)(options.limit, 'limit', 20);
+        const shown = memories.slice(0, limit);
+        if (options.json) {
+            console.log(JSON.stringify(shown.map(m => ({
+                id: m.id,
+                key: m.key,
+                type: m.type,
+                value: m.value,
+                project_id: m.project_id,
+                scope: m.scope,
+                is_active: m.is_active,
+                timestamp: m.timestamp,
+            })), null, 2));
+            return;
+        }
+        const typeFilter = options.type ? ` of type "${options.type}"` : '';
+        console.log(`\n🧠 Memories (${scopeLabel})\n`);
+        console.log(`${total} memor${total === 1 ? 'y' : 'ies'}${typeFilter}${total > shown.length ? ` — showing ${shown.length} (use --all or --limit)` : ''}\n`);
+        if (shown.length === 0) {
+            console.log('No memories found.\n');
+            return;
+        }
+        for (const m of shown) {
+            const inactive = m.is_active === false ? ' 💤 inactive' : '';
+            const when = m.timestamp ? new Date(m.timestamp).toLocaleString() : 'unknown time';
+            console.log(`[${m.id ?? '?'}] ${m.type}${inactive} · ${when}`);
+            console.log(`   ${this.truncateContent(this.extractContent(m.value))}`);
+            console.log(`   key: ${m.key}`);
+            console.log('');
+        }
+        this.logger.info('CLI', 'List completed', { scope: scopeLabel, total, shown: shown.length });
+    }
+    /**
+     * Pull the human-readable text out of a memory value, whether it's a raw
+     * string, a JSON string, or a structured object with a content/value field.
+     */
+    extractContent(value) {
+        let v = value;
+        if (typeof v === 'string') {
+            try {
+                v = JSON.parse(v);
+            }
+            catch {
+                return value;
+            }
+        }
+        if (v && typeof v === 'object') {
+            return String(v.content ?? v.value ?? v.text ?? JSON.stringify(v));
+        }
+        return String(v);
+    }
     /**
      * Export memories to a file
      */
@@ -1869,6 +1948,28 @@ async function main() {
         });
         process.exit(0);
     });
+    // List command — enumerate memories (no query, unlike `search`)
+    program
+        .command('list')
+        .description('List stored memories (no query needed; newest first)')
+        .option('-t, --type <type>', 'Filter by memory type (preference, failure, devops, ...)')
+        .option('-l, --limit <number>', 'Maximum memories to show', '20')
+        .option('--all', 'Show every memory in scope (ignores --limit)')
+        .option('--project <id>', 'List a specific project (includes universal memories)')
+        .option('--global', 'List memories across all projects')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        const cli = new ClaudeRecallCLI(program.opts());
+        cli.listMemories({
+            type: options.type,
+            limit: (0, parse_utils_1.parsePositiveInt)(options.limit, 'limit', 20),
+            all: options.all,
+            project: options.project,
+            global: options.global,
+            json: options.json,
+        });
+        process.exit(0);
+    });
     // Stats command
     program
         .command('stats')

package/docs/using-claude-code-subscription-instead-of-api-key.md

@@ -0,0 +1,69 @@
+# Wiring a project to the Claude Code subscription (no API key)
+
+The mechanism: don't call the Anthropic API at all — **shell out to the `claude`
+CLI**, which is already authenticated by the user's Claude Code subscription
+login. No key, no billing setup; it borrows the session the user logged into.
+
+> Applies to any project. Replace the placeholder name (`MY_APP_NESTED`) with
+> your own convention.
+
+## The core idea
+
+`claude -p "<prompt>"` runs a one-shot, non-interactive completion using the
+subscription auth. Your project spawns it as a subprocess and reads stdout.
+That's the whole trick.
+
+```bash
+claude -p "Summarize this in one line: ..."      # prints completion to stdout, exits
+```
+
+## Wiring it into any project
+
+Spawn it non-interactively (never through a shell string — pass args to avoid
+injection):
+
+```ts
+import { spawn } from 'node:child_process';
+
+function complete(prompt: string, timeoutMs = 60_000): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const p = spawn('claude', ['-p', prompt], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: timeoutMs,
+      env: { ...process.env, MY_APP_NESTED: '1' }, // recursion guard
+    });
+    let out = '', err = '';
+    p.stdout.on('data', d => (out += d));
+    p.stderr.on('data', d => (err += d));
+    p.on('close', code =>
+      code === 0 ? resolve(out.trim()) : reject(new Error(err || `exit ${code}`)));
+    p.on('error', reject);
+  });
+}
+```
+
+## The things that bite people
+
+- **Recursion.** If your code runs *inside* a Claude Code session (a hook, an
+  MCP tool) and then spawns `claude -p`, that child can trigger the same hook
+  and fork-bomb. Set a sentinel env var on the child and bail at the top of your
+  entry point if it's present.
+- **Availability.** Require `claude` to be installed and logged in. If it's not
+  on `PATH` (`ENOENT`), surface a clear error telling the user to install the
+  CLI and run `claude login` — don't crash silently.
+- **Timeouts.** The CLI is a full agent process, slower and heavier than a raw
+  API call. Always set a timeout and handle the null result; never block your
+  main flow on it.
+- **Structured output.** `-p` returns prose. If you need JSON, say so in the
+  prompt and parse defensively (treat malformed output as a no-op). Add
+  `--output-format json` if you want the CLI's own envelope instead.
+
+## Setup, once
+
+```bash
+claude login          # authenticate the subscription — no key involved
+claude -p "ping"      # verify it responds
+```
+
+That's all a fresh clone needs: an installed, logged-in `claude` CLI. No
+secrets, no `ANTHROPIC_API_KEY`, no billing configuration.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.36.0",
+  "version": "0.36.1",
   "description": "Persistent memory for Claude Code and Pi with native Skills integration, automatic capture, failure learning, and project scoping",
   "main": "dist/index.js",
   "bin": {
@@ -102,7 +102,7 @@
     "typescript-eslint": "^8.63.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.110.0",
+    "@anthropic-ai/sdk": "^0.111.0",
     "better-sqlite3": "^12.2.0",
     "chalk": "^5.5.0",
     "commander": "^14.0.3"