openclaw-langcache 1.1.0 → 1.2.0

package/README.md

@@ -1,6 +1,8 @@
 # openclaw-langcache
 
-Semantic caching skill for [OpenClaw](https://openclaw.ai) and [Claude Code](https://claude.ai/code) using [Redis LangCache](https://redis.io/langcache/).
+Semantic caching skill for [OpenClaw](https://openclaw.ai) using [Redis LangCache](https://redis.io/langcache/).
+
+> **For Claude Code users:** See [claude-code-langcache](https://www.npmjs.com/package/claude-code-langcache)
 
 Reduce LLM costs and latency by caching responses for semantically similar queries, with built-in privacy and security guardrails.
 
@@ -23,9 +25,7 @@ Reduce LLM costs and latency by caching responses for semantically similar queri
 npm install -g openclaw-langcache
 ```
 
-The skill will be automatically installed to:
-- **OpenClaw**: `~/.openclaw/workspace/skills/langcache/`
-- **Claude Code**: `~/.claude/skills/langcache/`
+The skill will be automatically installed to `~/.openclaw/workspace/skills/langcache/`
 
 ### Via Git
 

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "openclaw-langcache",
-  "version": "1.1.0",
-  "description": "Semantic caching skill for OpenClaw and Claude Code using Redis LangCache",
+  "version": "1.2.0",
+  "description": "Semantic caching skill for OpenClaw using Redis LangCache",
   "keywords": [
     "openclaw",
-    "claude-code",
     "skill",
     "langcache",
     "redis",
@@ -23,11 +22,10 @@
   },
   "license": "MIT",
   "author": {
-    "name": "OpenClaw Contributors"
+    "name": "Manvinder Singh"
   },
   "files": [
     "skills/",
-    "claude-skills/",
     "scripts/",
     "README.md",
     "LICENSE"
@@ -42,10 +40,5 @@
     "type": "skill",
     "skills": ["langcache"],
     "installPath": "skills/"
-  },
-  "claude-code": {
-    "type": "skill",
-    "skills": ["langcache"],
-    "installPath": "claude-skills/"
   }
 }

package/scripts/postinstall.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Postinstall script for openclaw-langcache
- * Installs the skill to both OpenClaw and Claude Code workspaces
+ * Installs the skill to OpenClaw workspace
  */
 
 const fs = require('fs');
@@ -10,26 +10,16 @@ const os = require('os');
 
 const SKILL_NAME = 'langcache';
 
-// Get installation paths
-function getInstallPaths() {
+function getOpenClawPath() {
   const home = os.homedir();
-
-  return {
-    openclaw: path.join(
-      process.env.OPENCLAW_HOME || path.join(home, '.openclaw'),
-      'workspace', 'skills'
-    ),
-    claude: path.join(
-      process.env.CLAUDE_HOME || path.join(home, '.claude'),
-      'skills'
-    )
-  };
+  return path.join(
+    process.env.OPENCLAW_HOME || path.join(home, '.openclaw'),
+    'workspace', 'skills'
+  );
 }
 
-// Recursively copy directory
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
-
   const entries = fs.readdirSync(src, { withFileTypes: true });
 
   for (const entry of entries) {
@@ -40,8 +30,6 @@ function copyDir(src, dest) {
       copyDir(srcPath, destPath);
     } else {
       fs.copyFileSync(srcPath, destPath);
-
-      // Make shell scripts and python files executable
       if (entry.name.endsWith('.sh') || entry.name.endsWith('.py')) {
         fs.chmodSync(destPath, 0o755);
       }
@@ -49,67 +37,45 @@ function copyDir(src, dest) {
   }
 }
 
-function installSkill(name, srcDir, destDir, skillSrcPath) {
-  const destPath = path.join(destDir, SKILL_NAME);
-
-  if (!fs.existsSync(skillSrcPath)) {
-    console.log(`  ⚠ ${name}: Source not found, skipping`);
-    return false;
-  }
-
-  // Create skills directory if needed
-  fs.mkdirSync(destDir, { recursive: true });
-
-  // Check if already exists
-  if (fs.existsSync(destPath)) {
-    console.log(`  ⚠ ${name}: Already exists at ${destPath}`);
-    console.log(`     To update: rm -rf ${destPath} && npm install openclaw-langcache`);
-    return false;
-  }
-
-  // Copy skill
-  copyDir(skillSrcPath, destPath);
-  console.log(`  ✓ ${name}: Installed to ${destPath}`);
-  return true;
-}
-
 function main() {
-  console.log('\n📦 Installing langcache skill...\n');
+  console.log('\n📦 Installing langcache skill for OpenClaw...\n');
 
   try {
-    const paths = getInstallPaths();
+    const skillsPath = getOpenClawPath();
+    const destPath = path.join(skillsPath, SKILL_NAME);
     const packageRoot = path.dirname(__dirname);
+    const srcPath = path.join(packageRoot, 'skills', SKILL_NAME);
 
-    let installed = 0;
-
-    // Install OpenClaw skill
-    const openclawSrc = path.join(packageRoot, 'skills', SKILL_NAME);
-    if (installSkill('OpenClaw', 'skills', paths.openclaw, openclawSrc)) {
-      installed++;
+    if (!fs.existsSync(srcPath)) {
+      console.log('Source skill not found, skipping');
+      return;
     }
 
-    // Install Claude Code skill
-    const claudeSrc = path.join(packageRoot, 'claude-skills', SKILL_NAME);
-    if (installSkill('Claude Code', 'claude-skills', paths.claude, claudeSrc)) {
-      installed++;
-    }
+    fs.mkdirSync(skillsPath, { recursive: true });
 
-    if (installed > 0) {
-      console.log('\n✅ Installation complete!\n');
-      console.log('Next steps:');
-      console.log('1. Set your Redis LangCache credentials:');
-      console.log('   export LANGCACHE_HOST=your-instance.redis.cloud');
-      console.log('   export LANGCACHE_CACHE_ID=your-cache-id');
-      console.log('   export LANGCACHE_API_KEY=your-api-key');
-      console.log('');
-      console.log('2. The skill auto-activates when you mention "semantic caching"');
-      console.log('   or invoke manually with /langcache');
-      console.log('');
+    if (fs.existsSync(destPath)) {
+      console.log(`⚠ Skill already exists at ${destPath}`);
+      console.log('  To update: rm -rf ~/.openclaw/workspace/skills/langcache && npm install -g openclaw-langcache');
+      return;
     }
 
+    copyDir(srcPath, destPath);
+
+    console.log(`✓ Installed to ${destPath}\n`);
+    console.log('Next steps:');
+    console.log('1. Set your Redis LangCache credentials:');
+    console.log('   export LANGCACHE_HOST=your-instance.redis.cloud');
+    console.log('   export LANGCACHE_CACHE_ID=your-cache-id');
+    console.log('   export LANGCACHE_API_KEY=your-api-key');
+    console.log('');
+    console.log('2. The skill auto-activates when you mention "semantic caching"');
+    console.log('   or invoke manually with /langcache');
+    console.log('');
+    console.log('For Claude Code users: npm install -g claude-code-langcache\n');
+
   } catch (err) {
     console.warn(`⚠ Warning: ${err.message}`);
-    console.warn('You can manually copy skills from node_modules/openclaw-langcache/');
+    console.warn('Manually copy from node_modules/openclaw-langcache/skills/');
   }
 }
 

package/claude-skills/langcache/SKILL.md

@@ -1,173 +0,0 @@
----
-name: langcache
-description: This skill should be used when the user asks to "enable semantic caching", "cache LLM responses", "reduce API costs", "speed up AI responses", "configure LangCache", "check the cache", or mentions Redis LangCache, semantic similarity caching, or LLM response caching. Provides integration with Redis LangCache managed service for semantic caching of prompts and responses.
-version: 1.0.0
-tools: Read, Bash, WebFetch
----
-
-# Redis LangCache Semantic Caching
-
-Integrate [Redis LangCache](https://redis.io/langcache/) for semantic caching of LLM prompts and responses. Reduces costs and latency by returning cached results for semantically similar queries.
-
-## Prerequisites
-
-Set credentials in environment or `~/.claude/settings.local.json`:
-
-```bash
-export LANGCACHE_HOST=your-instance.redis.cloud
-export LANGCACHE_CACHE_ID=your-cache-id
-export LANGCACHE_API_KEY=your-api-key
-```
-
-## Quick Reference
-
-| Operation | Command |
-|-----------|---------|
-| Search cache | `./scripts/langcache.sh search "query"` |
-| Store response | `./scripts/langcache.sh store "prompt" "response"` |
-| Check if blocked | `./scripts/langcache.sh check "text"` |
-| Delete entry | `./scripts/langcache.sh delete --id <id>` |
-| Flush cache | `./scripts/langcache.sh flush` |
-
-## Default Caching Policy
-
-This policy is **enforced automatically** by the CLI and integration code.
-
-### CACHEABLE (white-list)
-
-| Category | Examples | Threshold |
-|----------|----------|-----------|
-| Factual Q&A | "What is X?", "How does Y work?" | 0.90 |
-| Definitions / docs | API docs, command help | 0.90 |
-| Command explanations | "What does `git rebase` do?" | 0.92 |
-| Reply templates | "polite no", "follow-up", "intro" | 0.88 |
-| Style transforms | "make this warmer/shorter" | 0.85 |
-
-### NEVER CACHE (hard blocks)
-
-| Category | Patterns | Reason |
-|----------|----------|--------|
-| **Temporal** | today, tomorrow, deadline, ETA, "in 20 min" | Stale immediately |
-| **Credentials** | API keys, passwords, tokens, OTP/2FA | Security |
-| **Identifiers** | emails, phones, account IDs, UUIDs | Privacy/PII |
-| **Personal** | "my wife said", relationships, private chats | Privacy |
-
-## Core Operations
-
-### Search for Cached Response
-
-Before calling an LLM, check for semantically similar cached response:
-
-```bash
-# Basic search
-./scripts/langcache.sh search "What is semantic caching?"
-
-# With similarity threshold (0.0-1.0, higher = stricter)
-./scripts/langcache.sh search "What is semantic caching?" --threshold 0.95
-
-# With attribute filtering
-./scripts/langcache.sh search "query" --attr "model=gpt-5"
-```
-
-**Response (hit):**
-```json
-{"hit": true, "response": "...", "similarity": 0.94, "entryId": "abc123"}
-```
-
-**Response (miss):**
-```json
-{"hit": false}
-```
-
-**Response (blocked):**
-```json
-{"hit": false, "blocked": true, "reason": "temporal_info"}
-```
-
-### Store New Response
-
-After LLM call, cache for future use:
-
-```bash
-# Basic store
-./scripts/langcache.sh store "What is Redis?" "Redis is an in-memory data store..."
-
-# With attributes for organization/filtering
-./scripts/langcache.sh store "prompt" "response" --attr "model=gpt-5" --attr "category=factual"
-```
-
-### Check Policy Compliance
-
-Test if content would be blocked:
-
-```bash
-./scripts/langcache.sh check "What's on my calendar today?"
-# Output: BLOCKED: temporal_info
-
-./scripts/langcache.sh check "What is Redis?"
-# Output: ALLOWED: Content can be cached
-```
-
-### Delete Entries
-
-```bash
-# By ID
-./scripts/langcache.sh delete --id "abc123"
-
-# By attributes (bulk)
-./scripts/langcache.sh delete --attr "model=gpt-4"
-```
-
-### Flush Cache
-
-```bash
-./scripts/langcache.sh flush  # Interactive confirmation
-```
-
-## Integration Pattern
-
-Recommended cache-aside pattern for agent workflows:
-
-```
-1. Receive user prompt
-2. Check policy: is it cacheable?
-   - If blocked → skip cache, call LLM
-3. Search LangCache for similar cached response
-   - If hit (similarity ≥ threshold) → return cached
-4. Call LLM API
-5. Store prompt + response in LangCache
-6. Return response
-```
-
-## Search Strategies
-
-| Strategy | Description |
-|----------|-------------|
-| `semantic` (default) | Vector similarity matching |
-| `exact` | Case-insensitive exact match |
-| `exact,semantic` | Try exact first, fall back to semantic |
-
-```bash
-./scripts/langcache.sh search "query" --strategy "exact,semantic"
-```
-
-## Attributes for Cache Partitioning
-
-Use attributes to organize and filter cache entries:
-
-| Attribute | Purpose |
-|-----------|---------|
-| `model` | Separate caches per LLM model |
-| `category` | `factual`, `template`, `style`, `command` |
-| `version` | Invalidate when prompts change |
-| `user_id` | Per-user isolation (if needed) |
-
-## References
-
-- [API Reference](references/api-reference.md) - Complete REST API documentation
-- [Best Practices](references/best-practices.md) - Optimization techniques
-
-## Examples
-
-- [examples/basic-caching.sh](examples/basic-caching.sh) - Shell workflow
-- [examples/agent-integration.py](examples/agent-integration.py) - Python pattern with policy enforcement