clew-code 0.2.29 → 0.2.30

package/scripts/preload.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env bun
+/**
+ * Context Preloader
+ *
+ * Prepares module context before Claude Code starts editing.
+ * Usage: bun run scripts/preload.ts <module-name>
+ *        bun run scripts/preload.ts src/bridge
+ *        bun run scripts/preload.ts src/services/ai
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs'
+import { join, dirname, basename } from 'path'
+import { execSync } from 'child_process'
+
+const ROOT = join(import.meta.dirname, '..')
+const SRC = join(ROOT, 'src')
+const CONTEXT_DIR = join(ROOT, '.clew', 'context')
+
+const moduleArg = process.argv[2]
+if (!moduleArg) {
+  console.error('Usage: bun run scripts/preload.ts <module-path>')
+  console.error('  e.g. bun run scripts/preload.ts bridge')
+  console.error('  e.g. bun run scripts/preload.ts src/bridge')
+  process.exit(1)
+}
+
+const modPath = moduleArg.replace(/\\/g, '/').replace(/^src\//, '')
+const targetDir = join(SRC, modPath)
+
+function run(cmd: string): string {
+  try {
+    return execSync(cmd, { cwd: ROOT, encoding: 'utf-8', timeout: 15000, stdio: ['pipe', 'pipe', 'ignore'] })
+  } catch (e: any) {
+    return e.stdout || ''
+  }
+}
+
+function findFiles(dir: string): string[] {
+  try {
+    const entries = readdirSync(dir)
+    return entries
+      .filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))
+      .map(f => join(dir, f))
+      .filter(f => statSync(f).isFile())
+  } catch {
+    return []
+  }
+}
+
+// ── Gather data ──
+const files = findFiles(targetDir)
+
+const md: string[] = []
+md.push(`# Context: ${modPath}`)
+md.push(`_Preloaded ${new Date().toISOString().slice(0, 16).replace('T', ' ')}_`)
+md.push('')
+
+// Summary
+md.push(`## Scope`)
+md.push('')
+md.push(`Module: \`${modPath}\``)
+md.push(`Files: ${files.length}`)
+md.push('')
+
+// File listing with sizes
+md.push(`## Files`)
+md.push('')
+md.push(`| File | Lines | Exports | TODOs |`)
+md.push(`|------|-------|---------|-------|`)
+
+let totalLines = 0
+for (const file of files) {
+  const relName = file.replace(/\\/g, '/').replace(ROOT.replace(/\\/g, '/') + '/', '')
+  const content = readFileSync(file, 'utf-8')
+  const lines = content.split('\n').length
+  totalLines += lines
+
+  const exports = content.match(/export (async )?(function|const|class|interface|type) [a-zA-Z_$][a-zA-Z0-9_$]*/g) || []
+  const exportList = exports.map(e => e.split(/\s+/).pop()).filter(Boolean).slice(0, 8).join(', ')
+  const todos = (content.match(/\bTODO|FIXME\b/g) || []).length
+
+  md.push(`| ${relName} | ${lines} | ${exportList || '-'} | ${todos || '-'} |`)
+}
+
+md.push(`| **Total** | **${totalLines}** | | |`)
+md.push('')
+
+// Internal dependencies
+md.push(`## Internal Dependencies`)
+md.push('')
+md.push('```')
+const deps = files.map(f => {
+  const c = readFileSync(f, 'utf-8')
+  return [...c.matchAll(/from\s+['"](src\/[^'"]+)['"]/g)].map(m => m[1])
+}).flat()
+const uniqueDeps = [...new Set(deps)].sort()
+for (const d of uniqueDeps) md.push(d)
+if (!uniqueDeps.length) md.push('(none)')
+md.push('```')
+md.push('')
+
+// Recent git history
+md.push(`## Recent Changes`)
+md.push('')
+md.push('```')
+try {
+  const gitLog = run(`git log --oneline -10 -- "src/${modPath}/"`).trim()
+  md.push(gitLog || '(no recent changes)')
+} catch {
+  md.push('(no git history)')
+}
+md.push('```')
+md.push('')
+
+// Key types
+const typePattern = /export (interface|type) (\w+)/g
+const allTypes: string[] = []
+for (const file of files) {
+  const c = readFileSync(file, 'utf-8')
+  let m: RegExpExecArray | null
+  while ((m = typePattern.exec(c)) !== null) allTypes.push(m[2])
+}
+if (allTypes.length) {
+  md.push(`## Key Types`)
+  md.push('')
+  md.push('- ' + [...new Set(allTypes)].join('\n- '))
+  md.push('')
+}
+
+// Open TODOs
+const allTodos: { file: string; line: string }[] = []
+for (const file of files) {
+  const c = readFileSync(file, 'utf-8')
+  const lines = c.split('\n')
+  lines.forEach((l, i) => {
+    if (/\bTODO|FIXME\b/.test(l)) {
+      const text = l.replace(/^\s*\/\/\s*/, '').replace(/^\s*/, '').slice(0, 80)
+      allTodos.push({ file: file.replace(/\\/g, '/').replace(ROOT.replace(/\\/g, '/') + '/', ''), line: text })
+    }
+  })
+}
+
+if (allTodos.length) {
+  md.push(`## Open TODOs`)
+  md.push('')
+  for (const t of allTodos) md.push(`- \`${t.file}\`: ${t.line}`)
+  md.push('')
+}
+
+// Write
+mkdirSync(CONTEXT_DIR, { recursive: true })
+const outPath = join(CONTEXT_DIR, `${modPath.replace(/\//g, '-')}.md`)
+writeFileSync(outPath, md.join('\n'), 'utf-8')
+
+console.log(`\n✅ Preloaded: ${modPath}`)
+console.log(`   ${files.length} files, ${totalLines} lines`)
+console.log(`   Saved to: ${outPath}`)
+console.log('')
+console.log('Claude Code can now read this context via Read tool.')

package/scripts/rename-content-peer-to-swarm.mjs

@@ -0,0 +1,67 @@
+/**
+ * Content rename: peer -> swarm in all Swarm* tool files
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+function walk(dir) {
+  const r = [];
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const f = path.join(dir, e.name);
+    if (e.isDirectory()) r.push(...walk(f));
+    else if (e.name.endsWith('.ts') || e.name.endsWith('.tsx')) r.push(f);
+  }
+  return r;
+}
+
+const dirs = [
+  'src/tools/SwarmBroadcastTool',
+  'src/tools/SwarmDisconnectTool',
+  'src/tools/SwarmDiscoverTool',
+  'src/tools/SwarmJoinTool',
+  'src/tools/SwarmListMessagesTool',
+  'src/tools/SwarmListRolesTool',
+  'src/tools/SwarmPingTool',
+  'src/tools/SwarmRunTool',
+  'src/tools/SwarmSendMessageTool',
+  'src/tools/SwarmSetNameTool',
+  'src/tools/SwarmSetRoleTool',
+  'src/tools/SwarmShareTool',
+  'src/tools/SwarmSpawnTool',
+  'src/tools/ProcessSwarmTool',
+  'src/tools/CodexSwarmTool',
+  'src/swarm',
+];
+
+const files = [];
+for (const d of dirs) {
+  if (fs.existsSync(d)) files.push(...walk(d));
+}
+
+for (const f of files) {
+  let c = fs.readFileSync(f, 'utf-8');
+  const orig = c;
+
+  // PeerXxx -> SwarmXxx (class/identifier names)
+  c = c.replace(/\bPeer(Broadcast|Disconnect|Discover|Join|ListMessages|ListRoles|Ping|Run|SendMessage|SetName|SetRole|Share|Spawn|Info|Help|Server|Store|Discovery|StatusLine)\b/g, 'Swarm$1');
+  c = c.replace(/\bProcessPeer(Provider|Tool)\b/g, 'ProcessSwarm$1');
+  c = c.replace(/\bCodexPeerTool\b/g, 'CodexSwarmTool');
+
+  // peer_xxx -> swarm_xxx (tool name constants)
+  c = c.replace(/peer_/g, 'swarm_');
+
+  // peerXxx -> swarmXxx (camelCase variables)
+  c = c.replace(/\bpeer(Server|Store|Discovery|Port|Name|Info|List|Count|Connection|Sharing|Health)\b/g, 'swarm$1');
+
+  // usePeerAutoInject -> useSwarmAutoInject
+  c = c.replace(/\busePeerAutoInject\b/g, 'useSwarmAutoInject');
+
+  // /peer -> /swarm (command paths)
+  c = c.replace(/\/peer\b/g, '/swarm');
+
+  if (c !== orig) {
+    fs.writeFileSync(f, c, 'utf-8');
+    console.log('OK:', f);
+  }
+}
+console.log('DONE');

package/scripts/rename-hooks-mesh.mjs

@@ -0,0 +1,6 @@
+import fs from 'fs';
+for (const f of fs.readdirSync('src/hooks')) {
+  const nn = f.replace(/A2A/g, 'Mesh').replace(/a2a/g, 'mesh');
+  if (nn !== f) fs.renameSync('src/hooks/' + f, 'src/hooks/' + nn);
+}
+console.log('DONE');

package/scripts/rename-peer-to-swarm.mjs

@@ -0,0 +1,62 @@
+/**
+ * Bulk rename: peer -> swarm across all source files
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+function walk(dir) {
+  const results = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!entry.name.startsWith('.') && entry.name !== 'node_modules' && entry.name !== 'dist') {
+        results.push(...walk(full));
+      }
+    } else if (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+// Only replace import paths — safe, targeted changes
+const replacements = [
+  // Import paths for peer/ directory
+  [/from ['"]\.\.\/peer\//g, `from '../swarm/`],
+  [/from ['"]\.\/peer\//g, `from './swarm/`],
+  [/from ['"]\.\.\/\.\.\/peer\//g, `from '../../swarm/`],
+  [/from ['"]\.\.\/\.\.\/\.\.\/peer\//g, `from '../../../swarm/`],
+
+  // Import paths for tools/Peer* -> tools/Swarm*
+  [/from ['"]\.\.\/\.\.\/tools\/PeerInfoTool\//g, `from '../../tools/SwarmInfoTool/`],
+  [/from ['"]\.\.\/tools\/PeerInfoTool\//g, `from '../tools/SwarmInfoTool/`],
+  [/from ['"]\.\/PeerInfoTool\//g, `from './SwarmInfoTool/`],
+  [/from ['"]\.\.\/\.\.\/tools\/PeerHelpTool\//g, `from '../../tools/SwarmHelpTool/`],
+  [/from ['"]\.\.\/tools\/PeerHelpTool\//g, `from '../tools/SwarmHelpTool/`],
+  [/from ['"]\.\/PeerHelpTool\//g, `from './SwarmHelpTool/`],
+  [/from ['"]\.\.\/peer\//g, `from '../swarm/`],
+];
+
+const srcDir = 'src';
+const files = walk(srcDir);
+let totalChanged = 0;
+
+for (const file of files) {
+  let content = fs.readFileSync(file, 'utf-8');
+  let changed = false;
+
+  for (const [pattern, replacement] of replacements) {
+    if (pattern.test(content)) {
+      content = content.replace(pattern, replacement);
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    fs.writeFileSync(file, content, 'utf-8');
+    totalChanged++;
+    console.log('Updated:', file);
+  }
+}
+
+console.log(`\nTotal files updated: ${totalChanged}`);

package/scripts/run_devcontainer_claude_code.ps1

@@ -0,0 +1,152 @@
+<#
+.SYNOPSIS
+    Automates the setup and connection to a DevContainer environment using either Docker or Podman on Windows.
+
+.DESCRIPTION
+    This script automates the process of initializing, starting, and connecting to a DevContainer
+    using either Docker or Podman as the container backend. It must be executed from the root
+    directory of your project and assumes the script is located in a 'Script' subdirectory.
+
+.PARAMETER Backend
+    Specifies the container backend to use. Valid values are 'docker' or 'podman'.
+
+.EXAMPLE
+    .\Script\run_devcontainer_claude_code.ps1 -Backend docker
+    Uses Docker as the container backend.
+
+.EXAMPLE
+    .\Script\run_devcontainer_claude_code.ps1 -Backend podman
+    Uses Podman as the container backend.
+
+.NOTES
+    Project Structure:
+    Project/
+    ├── .devcontainer/
+    └── Script/
+        └── run_devcontainer_claude_code.ps1
+#>
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory=$true)]
+    [ValidateSet('docker','podman')]
+    [string]$Backend
+)
+
+# Notify script start
+Write-Host "--- DevContainer Startup & Connection Script ---"
+Write-Host "Using backend: $($Backend)"
+
+# --- Prerequisite Check ---
+Write-Host "Checking for required commands..."
+try {
+    if (-not (Get-Command $Backend -ErrorAction SilentlyContinue)) {
+        throw "Required command '$($Backend)' not found."
+    }
+    Write-Host "- $($Backend) command found."
+    if (-not (Get-Command devcontainer -ErrorAction SilentlyContinue)) {
+        throw "Required command 'devcontainer' not found."
+    }
+    Write-Host "- devcontainer command found."
+}
+catch {
+    Write-Error "A required command is not installed or not in your PATH. $($_.Exception.Message)"
+    Write-Error "Please ensure both '$Backend' and 'devcontainer' are installed and accessible in your system's PATH."
+    exit 1
+}
+
+
+# --- Backend-Specific Initialization ---
+if ($Backend -eq 'podman') {
+    Write-Host "--- Podman Backend Initialization ---"
+
+    # --- Step 1a: Initialize Podman machine ---
+    Write-Host "Initializing Podman machine 'claudeVM'..."
+    try {
+        & podman machine init claudeVM
+        Write-Host "Podman machine 'claudeVM' initialized or already exists."
+    } catch {
+        Write-Error "Failed to initialize Podman machine: $($_.Exception.Message)"
+        exit 1 # Exit script on error
+    }
+
+    # --- Step 1b: Start Podman machine ---
+    Write-Host "Starting Podman machine 'claudeVM'..."
+    try {
+        & podman machine start claudeVM -q
+        Write-Host "Podman machine started or already running."
+    } catch {
+        Write-Error "Failed to start Podman machine: $($_.Exception.Message)"
+        exit 1
+    }
+
+    # --- Step 2: Set default connection ---
+    Write-Host "Setting default Podman connection to 'claudeVM'..."
+    try {
+        & podman system connection default claudeVM
+        Write-Host "Default connection set."
+    } catch {
+        Write-Warning "Failed to set default Podman connection (may be already set or machine issue): $($_.Exception.Message)"
+    }
+
+} elseif ($Backend -eq 'docker') {
+    Write-Host "--- Docker Backend Initialization ---"
+
+    # --- Step 1 & 2: Check Docker Desktop ---
+    Write-Host "Checking if Docker Desktop is running and docker command is available..."
+    try {
+        docker info | Out-Null
+        Write-Host "Docker Desktop (daemon) is running."
+    } catch {
+        Write-Error "Docker Desktop is not running or docker command not found."
+        Write-Error "Please ensure Docker Desktop is running."
+        exit 1
+    }
+}
+
+# --- Step 3: Bring up DevContainer ---
+Write-Host "Bringing up DevContainer in the current folder..."
+try {
+    $arguments = @('up', '--workspace-folder', '.')
+    if ($Backend -eq 'podman') {
+        $arguments += '--docker-path', 'podman'
+    }
+    & devcontainer @arguments
+    Write-Host "DevContainer startup process completed."
+} catch {
+    Write-Error "Failed to bring up DevContainer: $($_.Exception.Message)"
+    exit 1
+}
+
+# --- Step 4: Get DevContainer ID ---
+Write-Host "Finding the DevContainer ID..."
+$currentFolder = (Get-Location).Path
+
+try {
+    $containerId = (& $Backend ps --filter "label=devcontainer.local_folder=$currentFolder" --format '{{.ID}}').Trim()
+} catch {
+    $displayCommand = "$Backend ps --filter `"label=devcontainer.local_folder=$currentFolder`" --format '{{.ID}}'"
+    Write-Error "Failed to get container ID (Command: $displayCommand): $($_.Exception.Message)"
+    exit 1
+}
+
+if (-not $containerId) {
+    Write-Error "Could not find DevContainer ID for the current folder ('$currentFolder')."
+    Write-Error "Please check if 'devcontainer up' was successful and the container is running."
+    exit 1
+}
+Write-Host "Found container ID: $containerId"
+
+# --- Step 5 & 6: Execute command and enter interactive shell inside container ---
+Write-Host "Executing 'claude' command and then starting zsh session inside container $($containerId)..."
+try {
+    & $Backend exec -it $containerId zsh -c 'claude; exec zsh'
+    Write-Host "Interactive session ended."
+} catch {
+    $displayCommand = "$Backend exec -it $containerId zsh -c 'claude; exec zsh'"
+    Write-Error "Failed to execute command inside container (Command: $displayCommand): $($_.Exception.Message)"
+    exit 1
+}
+
+# Notify script completion
+Write-Host "--- Script completed ---"

package/scripts/scrape.py

@@ -0,0 +1,82 @@
+import sys
+import json
+import argparse
+from duckduckgo_search import DDGS
+from scrapling import Fetcher
+import trafilatura
+
+def run_search(query, max_results=5):
+    try:
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=max_results))
+            # Format to simple dict list
+            formatted = []
+            for r in results:
+                formatted.append({
+                    "title": r.get("title", ""),
+                    "url": r.get("href", ""),
+                    "body": r.get("body", "")
+                })
+            return {"status": "ok", "results": formatted}
+    except Exception as e:
+        return {"status": "failed", "error": str(e)}
+
+def run_scrape(url):
+    try:
+        # 1. Initialize Scrapling Fetcher
+        f = Fetcher()
+        
+        # 2. Get the response object stealthily
+        res = f.get(url)
+        
+        # 3. Retrieve HTML content and text
+        html = res.html_content
+        text = res.text
+        
+        # 4. Extract title via XPath selector
+        title_node = res.xpath('//title/text()').get()
+        title = title_node.strip() if title_node else ""
+        
+        # 5. Extract clean main text/Markdown and metadata using Trafilatura
+        clean_text = trafilatura.extract(
+            html, 
+            output_format='markdown', 
+            include_comments=False, 
+            include_tables=True
+        )
+        
+        # 6. Extract page metadata
+        meta = trafilatura.extract_metadata(html)
+        
+        result = {
+            "status": "ok",
+            "title": title or (meta.title if meta else ""),
+            "author": meta.author if meta else "",
+            "published_at": meta.date if meta else "",
+            "markdown": clean_text or text or "",
+            "url": url
+        }
+        return result
+    except Exception as e:
+        return {"status": "failed", "error": str(e)}
+
+def main():
+    parser = argparse.ArgumentParser(description="Stealth Web Search and Scraper Helper")
+    parser.add_argument("--search", type=str, help="Search query to run on DuckDuckGo")
+    parser.add_argument("--url", type=str, help="Web page URL to scrape")
+    parser.add_argument("--max-results", type=int, default=5, help="Max search results to return")
+    
+    args = parser.parse_args()
+    
+    if args.search:
+        result = run_search(args.search, args.max_results)
+        print(json.dumps(result))
+    elif args.url:
+        result = run_scrape(args.url)
+        print(json.dumps(result))
+    else:
+        print(json.dumps({"status": "failed", "error": "Specify either --search or --url"}))
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()