squish-memory 1.0.2 → 1.2.0

package/scripts/test-interactive.mjs

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from "node:child_process";
-import path from "node:path";
-
-const colors = {
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  cyan: "\x1b[36m",
-  red: "\x1b[31m",
-  reset: "\x1b[0m",
-  gray: "\x1b[90m"
-};
-
-const root = process.cwd();
-const testScriptPath = path.join(root, "scripts", "install-interactive.mjs");
-
-let testsRun = 0;
-let testsPassed = 0;
-let testsFailed = 0;
-
-function logTest(testName) {
-  testsRun++;
-  console.log(`\n${colors.cyan}TEST ${testsRun}:${colors.reset} ${testName}`);
-}
-
-function logPass(message) {
-  testsPassed++;
-  console.log(`  ${colors.green}✓${colors.reset} ${message}`);
-}
-
-function logFail(message, error) {
-  testsFailed++;
-  console.log(`  ${colors.red}✗${colors.reset} ${message}`);
-  if (error) {
-    console.log(`    ${colors.gray}${error}${colors.reset}`);
-  }
-}
-
-function logSkip(message) {
-  console.log(`  ${colors.yellow}○${colors.reset} ${message}`);
-}
-
-function runTest(description, args, envVars = {}, expectedExitCode = 0) {
-  logTest(description);
-  
-  return new Promise((resolve) => {
-    const child = spawn(process.execPath, [testScriptPath, ...args], {
-      stdio: ["inherit", "pipe", "pipe"],
-      timeout: 5000,
-      env: { ...process.env, ...envVars }
-    });
-    
-    let stdout = "";
-    let stderr = "";
-    
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    
-    child.on("close", (code) => {
-      if (code === expectedExitCode) {
-        logPass(`Exit code: ${code}`);
-      } else {
-        logFail(`Expected exit code ${expectedExitCode}, got ${code}`, stderr);
-      }
-      resolve({ code, stdout, stderr });
-    });
-    
-    child.on("error", (err) => {
-      logFail("Spawn failed", err.message);
-      resolve({ code: -1, stderr: err.message });
-    });
-  });
-}
-
-async function runTests() {
-  console.log(`${colors.cyan}═════════════════════════════════════════════${colors.reset}`);
-  console.log(`${colors.cyan}Interactive Installer Test Suite${colors.reset}`);
-  console.log(`${colors.cyan}═══════════════════════════════════════════${colors.reset}`);
-  console.log("");
-  
-  await runTest("Syntax check (no syntax errors)", ["--help"]);
-  
-  await runTest("Help flag displays usage", ["--help"]);
-  
-  await runTest("List flag shows available plugins", ["--list"]);
-  
-  await runTest("Auto mode with --all flag", ["--all", "--dry-run"]);
-  
-  await runTest("Auto mode with --select flag", ["--select=claude-code", "--dry-run"]);
-  
-  await runTest("Environment detection - CI mode", ["--list"], { CI: "true" });
-  
-  await runTest("Environment detection - NON_INTERACTIVE mode", ["--list"], { NON_INTERACTIVE: "1" });
-  
-  await runTest("Dry-run preview mode", ["--list", "--dry-run"]);
-  
-  await runTest("Multiple flag combination", ["--select=claude-code,openclaw", "--verbose", "--dry-run"]);
-  
-  await runTest("Invalid flag handling", ["--invalid-flag"], {}, 1);
-  
-  await runTest("Invalid plugin in --select", ["--select=nonexistent"], {}, 1);
-  
-  console.log("");
-  console.log(`${colors.cyan}═════════════════════════════════════════════${colors.reset}`);
-  console.log(`${colors.cyan}Test Summary${colors.reset}`);
-  console.log(`${colors.cyan}═══════════════════════════════════════════${colors.reset}`);
-  console.log("");
-  console.log(`  ${colors.gray}Total tests:${colors.reset} ${testsRun}`);
-  console.log(`  ${colors.green}Passed:${colors.reset} ${testsPassed}`);
-  console.log(`  ${colors.red}Failed:${colors.reset} ${testsFailed}`);
-  console.log("");
-  
-  if (testsFailed === 0) {
-    console.log(`${colors.green}All tests passed!${colors.reset}`);
-  } else {
-    console.log(`${colors.yellow}${testsFailed} test(s) failed${colors.reset}`);
-  }
-}
-
-runTests().then(() => {
-  process.exit(testsFailed > 0 ? 1 : 0);
-}).catch((err) => {
-  console.log(`${colors.red}Fatal test error:${colors.reset} ${err.message}`);
-  process.exit(1);
-});

package/scripts/verify-mcp.mjs

@@ -1,214 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import path from "node:path";
-import crypto from "node:crypto";
-import { spawnSync } from "node:child_process";
-
-const root = process.cwd();
-const defaultConfigPath = path.join(root, "config", "mcp.json");
-const defaultGeneratedDir = path.join(root, "generated", "mcp");
-const requiredFiles = [
-  "runtime.json",
-  "mcp-servers.json",
-  "mcporter.json",
-  "openclaw-memory-qmd.json",
-  "manifest.json"
-];
-
-function parseArgs(argv) {
-  const args = {
-    configPath: defaultConfigPath,
-    generatedDir: defaultGeneratedDir,
-    checkReproducibility: true
-  };
-
-  for (let i = 2; i < argv.length; i += 1) {
-    const token = argv[i];
-    if (token === "--config") {
-      args.configPath = path.resolve(argv[i + 1]);
-      i += 1;
-      continue;
-    }
-    if (token === "--generated") {
-      args.generatedDir = path.resolve(argv[i + 1]);
-      i += 1;
-      continue;
-    }
-    if (token === "--no-repro") {
-      args.checkReproducibility = false;
-      continue;
-    }
-    throw new Error(`Unknown argument: ${token}`);
-  }
-
-  return args;
-}
-
-function fail(message) {
-  throw new Error(message);
-}
-
-function readJson(filePath) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf8"));
-  } catch (error) {
-    fail(`Invalid JSON at ${filePath}: ${String(error)}`);
-  }
-}
-
-function checksum(filePath) {
-  const hash = crypto.createHash("sha256");
-  hash.update(fs.readFileSync(filePath));
-  return hash.digest("hex");
-}
-
-function assertServerShape(serverName, server) {
-  if (!server || typeof server !== "object") {
-    fail(`Server ${serverName} must be an object`);
-  }
-  if (typeof server.command !== "string" || server.command.length === 0) {
-    fail(`Server ${serverName} must include command`);
-  }
-  if (!Array.isArray(server.args)) {
-    fail(`Server ${serverName} must include args array`);
-  }
-  if (typeof server.transport !== "string" || server.transport.length === 0) {
-    fail(`Server ${serverName} must include transport`);
-  }
-  if (!server.env || typeof server.env !== "object") {
-    fail(`Server ${serverName} must include env object`);
-  }
-}
-
-function verifyGeneratedFiles(dirPath) {
-  for (const fileName of requiredFiles) {
-    const filePath = path.join(dirPath, fileName);
-    if (!fs.existsSync(filePath)) {
-      fail(`Missing generated file: ${fileName}`);
-    }
-  }
-}
-
-function verifyRuntime(runtime) {
-  const requiredKeys = [
-    "connectionTimeoutMs",
-    "requestTimeoutMs",
-    "maxConcurrentToolCalls",
-    "lazyToolDiscovery",
-    "resultMaxChars",
-    "retry"
-  ];
-  for (const key of requiredKeys) {
-    if (!(key in runtime)) {
-      fail(`runtime.json missing required key: ${key}`);
-    }
-  }
-}
-
-function verifyManifest(manifest, dirPath) {
-  if (manifest.mode !== "universal") {
-    fail("manifest mode must be universal");
-  }
-  if (!Array.isArray(manifest.files) || manifest.files.length === 0) {
-    fail("manifest files must be a non-empty array");
-  }
-
-  const expectedManifestEntries = [
-    "runtime.json",
-    "mcp-servers.json",
-    "mcporter.json",
-    "openclaw-memory-qmd.json"
-  ];
-
-  for (const fileName of expectedManifestEntries) {
-    const entry = manifest.files.find((item) => item.file === fileName);
-    if (!entry) {
-      fail(`manifest missing entry for ${fileName}`);
-    }
-    const actualHash = checksum(path.join(dirPath, fileName));
-    if (entry.sha256 !== actualHash) {
-      fail(`manifest checksum mismatch for ${fileName}`);
-    }
-  }
-}
-
-function verifyReproducibility(configPath, dirPath) {
-  const first = readJson(path.join(dirPath, "manifest.json"));
-  const firstChecksums = new Map(first.files.map((item) => [item.file, item.sha256]));
-
-  const run = spawnSync(
-    process.execPath,
-    ["scripts/generate-mcp.mjs", "--config", configPath, "--out", dirPath],
-    { cwd: root, encoding: "utf8" }
-  );
-
-  if (run.status !== 0) {
-    fail(`Reproducibility generation failed: ${run.stderr || run.stdout}`);
-  }
-
-  const second = readJson(path.join(dirPath, "manifest.json"));
-  const secondChecksums = new Map(second.files.map((item) => [item.file, item.sha256]));
-
-  for (const [fileName, firstHash] of firstChecksums.entries()) {
-    const secondHash = secondChecksums.get(fileName);
-    if (!secondHash) {
-      fail(`Reproducibility check missing ${fileName} in second manifest`);
-    }
-    if (firstHash !== secondHash) {
-      fail(`Reproducibility mismatch for ${fileName}`);
-    }
-  }
-}
-
-function main() {
-  const args = parseArgs(process.argv);
-
-  if (!fs.existsSync(args.configPath)) {
-    fail(`Config file not found: ${args.configPath}`);
-  }
-  if (!fs.existsSync(args.generatedDir)) {
-    fail(`Generated directory not found: ${args.generatedDir}`);
-  }
-
-  verifyGeneratedFiles(args.generatedDir);
-
-  const runtime = readJson(path.join(args.generatedDir, "runtime.json"));
-  verifyRuntime(runtime);
-
-  const mcpServers = readJson(path.join(args.generatedDir, "mcp-servers.json"));
-  if (!mcpServers.mcpServers || typeof mcpServers.mcpServers !== "object") {
-    fail("mcp-servers.json must include mcpServers object");
-  }
-  const serverEntries = Object.entries(mcpServers.mcpServers);
-  if (serverEntries.length === 0) {
-    fail("mcp-servers.json must include at least one server");
-  }
-  for (const [name, server] of serverEntries) {
-    assertServerShape(name, server);
-  }
-
-  const mcporter = readJson(path.join(args.generatedDir, "mcporter.json"));
-  if (!Array.isArray(mcporter.imports) || mcporter.imports.length === 0) {
-    fail("mcporter.json must include imports array");
-  }
-  if (!mcporter.mcpServers || typeof mcporter.mcpServers !== "object") {
-    fail("mcporter.json must include mcpServers object");
-  }
-
-  const openclaw = readJson(path.join(args.generatedDir, "openclaw-memory-qmd.json"));
-  if (openclaw?.memory?.backend !== "qmd") {
-    fail("openclaw-memory-qmd.json must set memory.backend=qmd");
-  }
-
-  const manifest = readJson(path.join(args.generatedDir, "manifest.json"));
-  verifyManifest(manifest, args.generatedDir);
-
-  if (args.checkReproducibility) {
-    verifyReproducibility(args.configPath, args.generatedDir);
-  }
-
-  console.log("MCP verification passed");
-}
-
-main();

package/skills/memory-guide/SKILL.md

@@ -1,332 +0,0 @@
----
-name: memory-guide
-description: Expert guide for using Squish memory system v1.0.2. Use when managing persistent memory, storing context, recalling information, or optimizing memory usage across MCP clients.
-version: 1.0.2
-author: michielhdoteth
-tags: [memory, persistence, squish, guide, mcp, ai-assistant]
-emoji: book
----
-
-# Squish Memory System Guide v1.0.2
-
-You are an expert at using the Squish persistent memory system for AI coding assistants.
-
-## When to Use Squish Memory
-
-Use Squish memory tools proactively for:
-
-### 1. Storing Important Information
-- User preferences, project context, decisions made
-- Technical specifications, API patterns, architecture notes
-- Ongoing work, TODOs, blockers encountered
-
-### 2. Recalling Past Context
-- Previous conversations and decisions
-- Code patterns used in this project
-- User's coding style preferences
-
-### 3. Managing Session Context
-- Load relevant memories before starting complex tasks
-- Inject project-specific context
-- Maintain working memory across sessions
-
-## MCP Tools Reference
-
-### Storing Memories
-
-**Tool:** `squish_remember`
-
-Store new memories with automatic embedding.
-
-```typescript
-// Store a preference
-squish_remember({
-  content: "User prefers functional components with hooks over class components",
-  type: "preference",
-  tags: ["react", "preferences"]
-})
-
-// Store a fact
-squish_remember({
-  content: "API uses JWT tokens with 1-hour expiration",
-  type: "fact",
-  tags: ["auth", "api"]
-})
-
-// Store a decision
-squish_remember({
-  content: "Chose PostgreSQL over MongoDB for better relational data",
-  type: "decision",
-  tags: ["database", "architecture"]
-})
-```
-
-### Searching Memories
-
-**Tool:** `squish_search`
-
-Hybrid search across all memory types.
-
-```typescript
-// Basic search
-squish_search({ query: "authentication patterns", limit: 5 })
-
-// Search with project filter
-squish_search({ query: "database schema", project: "/path/to/project", limit: 10 })
-
-// Search specific memory type
-squish_search({ query: "user preferences", type: "preference" })
-```
-
-### Retrieving Memories
-
-**Tool:** `squish_recall`
-
-Retrieve a specific memory by ID.
-
-```typescript
-squish_recall({ memoryId: "uuid-here" })
-```
-
-### Deleting Memories
-
-**Tool:** `squish_forget`
-
-Delete a memory by ID.
-
-```typescript
-squish_forget({ memoryId: "uuid-here" })
-```
-
-### Updating Memories
-
-**Tool:** `squish_update`
-
-Update existing memory content, tags, or type.
-
-```typescript
-squish_update({
-  memoryId: "uuid-here",
-  content: "Updated content",
-  tags: ["new", "tags"],
-  type: "fact"
-})
-```
-
-### Graph Associations
-
-**Tool:** `squish_associate`
-
-Link related memories together.
-
-```typescript
-squish_associate({
-  fromMemoryId: "uuid-1",
-  toMemoryId: "uuid-2",
-  type: "relates_to",
-  weight: 0.8
-})
-```
-
-**Tool:** `squish_related`
-
-Find related memories via graph traversal.
-
-```typescript
-squish_related({
-  memoryId: "uuid-here",
-  depth: 2,
-  minWeight: 0.3
-})
-```
-
-### Context & Observations
-
-**Tool:** `squish_context`
-
-Get project context with relevant memories.
-
-```typescript
-squish_context({ project: "/path/to/project", limit: 10 })
-```
-
-**Tool:** `squish_observe`
-
-Record observations about your work.
-
-```typescript
-squish_observe({
-  type: "tool_use",
-  action: "Created new API endpoint",
-  summary: "Implemented POST /users endpoint",
-  target: "api/users.ts"
-})
-
-squish_observe({
-  type: "error",
-  action: "Database connection failed",
-  summary: "PostgreSQL timeout after 30s",
-  target: "db/index.ts"
-})
-```
-
-### QMD Search
-
-**Tool:** `squish_qmd_search`
-
-Search local markdown files using QMD.
-
-```typescript
-squish_qmd_search({ query: "authentication", limit: 10 })
-squish_qmd_search({ query: "react hooks", collection: "docs" })
-```
-
-### Utilities
-
-**Tool:** `squish_embed`
-
-Generate embeddings for text.
-
-```typescript
-squish_embed({ text: "Text to embed" })
-```
-
-**Tool:** `squish_health`
-
-Check system health.
-
-```typescript
-squish_health({})
-```
-
-**Tool:** `squish_stats`
-
-Get memory statistics.
-
-```typescript
-squish_stats({ project: "/path/to/project" })
-```
-
-**Tool:** `squish_projects`
-
-List all projects.
-
-```typescript
-squish_projects({})
-```
-
-## CLI Reference
-
-### Interactive Mode (Default)
-
-```bash
-squish
-```
-
-Shows menu:
-```
-[1] Start MCP Server (for Claude Code, etc.)
-[2] Start Web UI Only
-[3] Check Health Status
-[4] View Memory Stats
-[5] Open Installer Wizard
-[6] Show Help
-[0] Exit
-```
-
-### Server Commands
-
-```bash
-# Start MCP server (also starts Web UI)
-squish run mcp
-
-# Start Web UI only
-squish run web
-```
-
-### CLI Commands (for agents and scripting)
-
-```bash
-# Store a memory
-squish remember "User prefers TypeScript" --type preference
-
-# Search memories
-squish search "database schema" --limit 10
-
-# Get a memory by ID
-squish recall <uuid>
-
-# Check health
-squish health
-
-# View statistics
-squish stats
-
-# Manage core memory
-squish core_memory view
-squish core_memory edit persona --content "I am a helpful coding assistant"
-
-# Set importance
-squish set-importance <memory-id> --importance 80
-
-# Pin/unpin memory
-squish pin <memory-id>
-squish unpin <memory-id>
-
-# Consolidate old memories
-squish consolidate
-```
-
-## Best Practices
-
-1. **Store proactively**: Don't wait until end of session
-2. **Be specific**: Include context, timestamps, rationale
-3. **Use appropriate types**: Choose correct memory type and sector
-4. **Use associations**: Link related memories for better retrieval
-5. **Record observations**: Use `squish_observe` for tool usage patterns
-6. **Set importance**: Mark critical memories with high importance
-7. **Use namespaces**: Organize memories hierarchically for large projects
-
-## Memory Types
-
-- **observation**: Facts observed, patterns noticed, tool usage
-- **fact**: Technical facts, specifications
-- **decision**: Decisions made with rationale
-- **context**: Project/domain context
-- **preference**: User preferences
-
-## When to Use Each Tool
-
-| Task | Use |
-|------|-----|
-| Remember something important | `squish_remember` |
-| Find relevant past info | `squish_search` |
-| Get specific memory | `squish_recall` |
-| Delete incorrect memory | `squish_forget` |
-| Update stored info | `squish_update` |
-| Link related memories | `squish_associate` |
-| Find connected info | `squish_related` |
-| Get project overview | `squish_context` |
-| Record work observations | `squish_observe` |
-| Search local docs | `squish_qmd_search` |
-| Check system status | `squish_health` |
-| View memory stats | `squish_stats` |
-| Manage core memory | `squish core_memory` |
-| Set importance | `squish set-importance` |
-| Pin/unpin memory | `squish pin/unpin` |
-| Consolidate old memories | `squish consolidate` |
-
-## v1.0.1 Features
-
-**New in v1.0.1:**
-- Interactive wizard/menu as default (`squish`)
-- `squish run mcp` - Start MCP server
-- `squish run web` - Start Web UI only
-- Namespace support for hierarchical memory organization
-- Maintenance job scheduling system
-- Improved migration system for zero-downtime upgrades
-- Token estimation for memory content
-
-**All tools use consistent input schema patterns.**
-
-Remember: Squish is your persistent memory. Use it actively to maintain continuity across sessions and provide better assistance.