clew-code 0.2.28 → 0.2.30

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()

package/scripts/session.ts

@@ -0,0 +1,195 @@
+#!/usr/bin/env bun
+/**
+ * Session Bridge
+ *
+ * Saves & restores session context so Claude Code can pick up
+ * where it left off across sessions.
+ *
+ * Usage:
+ *   bun run session save     "กำลัง refactor bridge reconnect logic"
+ *   bun run session list     # ดู sessions ล่าสุด
+ *   bun run session restore  # โหลด session ล่าสุดกลับมา
+ *   bun run session drop     # ลบ current session
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync } from 'fs'
+import { join, dirname, basename } from 'path'
+import { execSync } from 'child_process'
+
+const ROOT = join(import.meta.dirname, '..')
+const SESSIONS_DIR = join(ROOT, '.clew', 'sessions')
+const CURRENT_LINK = join(SESSIONS_DIR, 'CURRENT.md')
+const MAX_SESSIONS = 20
+
+const cmd = process.argv[2]
+const message = process.argv.slice(3).join(' ')
+
+function run(cmd: string): string {
+  try {
+    return execSync(cmd, { cwd: ROOT, encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'ignore'] })
+  } catch (e: any) {
+    return e.stdout || ''
+  }
+}
+
+function ts(): string {
+  return new Date().toISOString().replace('T', ' ').slice(0, 19)
+}
+
+function sessionId(): string {
+  return new Date().toISOString().slice(0, 10) + '-' + Date.now().toString(36)
+}
+
+function getModifiedFiles(): string[] {
+  try {
+    const out = run('git diff --name-only --relative').trim()
+    const staged = run('git diff --cached --name-only --relative').trim()
+    const files = [...new Set([...out.split('\n'), ...staged.split('\n')])].filter(Boolean)
+    return files.filter(f => f.startsWith('src/'))
+  } catch {
+    return []
+  }
+}
+
+function getCurrentBranch(): string {
+  try {
+    return run('git branch --show-current').trim()
+  } catch {
+    return 'unknown'
+  }
+}
+
+function getRecentCommits(count = 5): string[] {
+  try {
+    return run(`git log --oneline -${count} -- .`).trim().split('\n').filter(Boolean)
+  } catch {
+    return []
+  }
+}
+
+// ── Commands ──
+
+if (cmd === 'save') {
+  const id = sessionId()
+  const branch = getCurrentBranch()
+  const modified = getModifiedFiles()
+  const commits = getRecentCommits(3)
+  const content = message || '(no description)'
+
+  mkdirSync(SESSIONS_DIR, { recursive: true })
+
+  const md = [
+    `# Session: ${id}`,
+    ``,
+    `- **Date**: ${ts()}`,
+    `- **Branch**: ${branch}`,
+    `- **Description**: ${content}`,
+    ``,
+  ]
+
+  if (modified.length) {
+    md.push(`## Modified Files`, ``)
+    for (const f of modified) md.push(`- \`${f}\``)
+    md.push(``)
+  }
+
+  if (commits.length) {
+    md.push(`## Recent Commits`, ``)
+    md.push('```')
+    for (const c of commits) md.push(c)
+    md.push('```')
+    md.push(``)
+  }
+
+  md.push(`## Notes`, ``)
+  md.push(`(add key decisions, pending items, or anything to remember)`)
+  md.push(``)
+
+  const filepath = join(SESSIONS_DIR, `${id}.md`)
+  writeFileSync(filepath, md.join('\n'), 'utf-8')
+  writeFileSync(CURRENT_LINK, `# Current Session\n\n${content}\n\nSee: ${id}.md`, 'utf-8')
+
+  console.log(`✅ Session saved: ${id}`)
+  console.log(`   ${filepath}`)
+  if (modified.length) console.log(`   ${modified.length} modified file(s)`)
+
+} else if (cmd === 'list') {
+  mkdirSync(SESSIONS_DIR, { recursive: true })
+  const files = readdirSync(SESSIONS_DIR)
+    .filter(f => f.endsWith('.md') && f !== 'CURRENT.md')
+    .sort()
+    .reverse()
+    .slice(0, MAX_SESSIONS)
+
+  if (files.length === 0) {
+    console.log('📭 No saved sessions')
+    process.exit(0)
+  }
+
+  console.log(`📋 Recent sessions (${files.length}):`)
+  console.log('')
+  for (const f of files) {
+    const content = readFileSync(join(SESSIONS_DIR, f), 'utf-8')
+    const firstLine = content.split('\n')[0] || f
+    const desc = content.match(/\*\*Description\*\*:\s*(.+)/)?.[1] || '(no description)'
+    const date = content.match(/\*\*Date\*\*:\s*(.+)/)?.[1] || '?'
+    console.log(`  ${firstLine.replace('# ', '')}`)
+    console.log(`    ${date} — ${desc}`)
+    console.log('')
+  }
+
+} else if (cmd === 'restore') {
+  if (!existsSync(CURRENT_LINK)) {
+    console.log('📭 No current session to restore')
+    process.exit(0)
+  }
+
+  const content = readFileSync(CURRENT_LINK, 'utf-8')
+  const refMatch = content.match(/See:\s+(.+\.md)/)
+  if (!refMatch) {
+    console.log('📭 No session file referenced')
+    process.exit(0)
+  }
+
+  const sessionFile = join(SESSIONS_DIR, refMatch[1])
+  if (!existsSync(sessionFile)) {
+    console.log(`📭 Session file not found: ${sessionFile}`)
+    process.exit(0)
+  }
+
+  const session = readFileSync(sessionFile, 'utf-8')
+  console.log('📋 Restoring session...')
+  console.log('')
+  console.log(session)
+
+} else if (cmd === 'drop') {
+  if (existsSync(CURRENT_LINK)) {
+    const content = readFileSync(CURRENT_LINK, 'utf-8')
+    const refMatch = content.match(/See:\s+(.+\.md)/)
+    if (refMatch) {
+      const sessionFile = join(SESSIONS_DIR, refMatch[1])
+      if (existsSync(sessionFile)) {
+        try { execSync(`rm "${sessionFile}"`) } catch {}
+        console.log(`🗑️  Removed: ${refMatch[1]}`)
+      }
+    }
+    try { execSync(`rm "${CURRENT_LINK}"`) } catch {}
+    console.log('✅ Session dropped')
+  } else {
+    console.log('📭 No current session')
+  }
+
+} else {
+  console.log(`
+Usage:
+  bun run session save "<description>"     — save current state
+  bun run session list                     — list recent sessions
+  bun run session restore                  — restore latest session
+  bun run session drop                     — drop current session
+
+Examples:
+  bun run session save "adding auth middleware"
+  bun run session save "fixing bridge reconnect bug"
+  bun run session list
+  `)
+}

package/scripts/sweep.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env bun
+
+import { lifecycle, STALE_UPVOTE_THRESHOLD } from "./issue-lifecycle.ts";
+
+// --
+
+const NEW_ISSUE = "https://github.com/JonusNattapong/ClaudeCode/issues/new/choose";
+const DRY_RUN = process.argv.includes("--dry-run");
+
+const CLOSE_MESSAGE = (reason: string) =>
+  `Closing for now — ${reason}. Please [open a new issue](${NEW_ISSUE}) if this is still relevant.`;
+
+// --
+
+async function githubRequest<T>(
+  endpoint: string,
+  method = "GET",
+  body?: unknown
+): Promise<T> {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) throw new Error("GITHUB_TOKEN required");
+
+  const response = await fetch(`https://api.github.com${endpoint}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "sweep",
+      ...(body && { "Content-Type": "application/json" }),
+    },
+    ...(body && { body: JSON.stringify(body) }),
+  });
+
+  if (!response.ok) {
+    if (response.status === 404) return {} as T;
+    const text = await response.text();
+    throw new Error(`GitHub API ${response.status}: ${text}`);
+  }
+
+  return response.json();
+}
+
+// --
+
+async function markStale(owner: string, repo: string) {
+  const staleDays = lifecycle.find((l) => l.label === "stale")!.days;
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - staleDays);
+
+  let labeled = 0;
+
+  console.log(`\n=== marking stale (${staleDays}d inactive) ===`);
+
+  for (let page = 1; page <= 10; page++) {
+    const issues = await githubRequest<any[]>(
+      `/repos/${owner}/${repo}/issues?state=open&sort=updated&direction=asc&per_page=100&page=${page}`
+    );
+    if (issues.length === 0) break;
+
+    for (const issue of issues) {
+      if (issue.pull_request) continue;
+      if (issue.locked) continue;
+      if (issue.assignees?.length > 0) continue;
+
+      const updatedAt = new Date(issue.updated_at);
+      if (updatedAt > cutoff) return labeled;
+
+      const alreadyStale = issue.labels?.some(
+        (l: any) => l.name === "stale" || l.name === "autoclose"
+      );
+      if (alreadyStale) continue;
+
+      const thumbsUp = issue.reactions?.["+1"] ?? 0;
+      if (thumbsUp >= STALE_UPVOTE_THRESHOLD) continue;
+
+      const base = `/repos/${owner}/${repo}/issues/${issue.number}`;
+
+      if (DRY_RUN) {
+        const age = Math.floor((Date.now() - updatedAt.getTime()) / 86400000);
+        console.log(`#${issue.number}: would label stale (${age}d inactive) — ${issue.title}`);
+      } else {
+        await githubRequest(`${base}/labels`, "POST", { labels: ["stale"] });
+        console.log(`#${issue.number}: labeled stale — ${issue.title}`);
+      }
+      labeled++;
+    }
+  }
+
+  return labeled;
+}
+
+async function closeExpired(owner: string, repo: string) {
+  let closed = 0;
+
+  for (const { label, days, reason } of lifecycle) {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    console.log(`\n=== ${label} (${days}d timeout) ===`);
+
+    for (let page = 1; page <= 10; page++) {
+      const issues = await githubRequest<any[]>(
+        `/repos/${owner}/${repo}/issues?state=open&labels=${label}&sort=updated&direction=asc&per_page=100&page=${page}`
+      );
+      if (issues.length === 0) break;
+
+      for (const issue of issues) {
+        if (issue.pull_request) continue;
+        if (issue.locked) continue;
+
+        const thumbsUp = issue.reactions?.["+1"] ?? 0;
+        if (thumbsUp >= STALE_UPVOTE_THRESHOLD) continue;
+
+        const base = `/repos/${owner}/${repo}/issues/${issue.number}`;
+
+        const events = await githubRequest<any[]>(`${base}/events?per_page=100`);
+
+        const labeledAt = events
+          .filter((e) => e.event === "labeled" && e.label?.name === label)
+          .map((e) => new Date(e.created_at))
+          .pop();
+
+        if (!labeledAt || labeledAt > cutoff) continue;
+
+        // Skip if a non-bot user commented after the label was applied.
+        // The triage workflow should remove lifecycle labels on human
+        // activity, but check here too as a safety net.
+        const comments = await githubRequest<any[]>(
+          `${base}/comments?since=${labeledAt.toISOString()}&per_page=100`
+        );
+        const hasHumanComment = comments.some(
+          (c) => c.user && c.user.type !== "Bot"
+        );
+        if (hasHumanComment) {
+          console.log(
+            `#${issue.number}: skipping (human activity after ${label} label)`
+          );
+          continue;
+        }
+
+        if (DRY_RUN) {
+          const age = Math.floor((Date.now() - labeledAt.getTime()) / 86400000);
+          console.log(`#${issue.number}: would close (${label}, ${age}d old) — ${issue.title}`);
+        } else {
+          await githubRequest(`${base}/comments`, "POST", { body: CLOSE_MESSAGE(reason) });
+          await githubRequest(base, "PATCH", { state: "closed", state_reason: "not_planned" });
+          console.log(`#${issue.number}: closed (${label})`);
+        }
+        closed++;
+      }
+    }
+  }
+
+  return closed;
+}
+
+// --
+
+const owner = process.env.GITHUB_REPOSITORY_OWNER;
+const repo = process.env.GITHUB_REPOSITORY_NAME;
+if (!owner || !repo)
+  throw new Error("GITHUB_REPOSITORY_OWNER and GITHUB_REPOSITORY_NAME required");
+
+if (DRY_RUN) console.log("DRY RUN — no changes will be made\n");
+
+const labeled = await markStale(owner, repo);
+const closed = await closeExpired(owner, repo);
+
+console.log(`\nDone: ${labeled} ${DRY_RUN ? "would be labeled" : "labeled"} stale, ${closed} ${DRY_RUN ? "would be closed" : "closed"}`);

package/scripts/write-discovery-test.cjs

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshDiscovery.test.ts';
+const code = `import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { MeshDiscovery, getGlobalDiscovery } from './MeshDiscovery.js';
+
+describe('MeshDiscovery', () => {
+  let discovery;
+  beforeEach(() => { process.env.CLEW_MESH_LAN = undefined; });
+  afterEach(() => { if (discovery) discovery.close(); });
+
+  test('constructor generates localId', () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.meshId).toBeTruthy();
+    expect(discovery.meshId.split('-').length).toBeGreaterThanOrEqual(3);
+  });
+
+  test('constructor accepts callbacks', () => {
+    let c = false;
+    discovery = new MeshDiscovery({ onPeerDiscovered: () => { c = true; } });
+    expect(discovery).toBeDefined();
+  });
+
+  test('setLocalName updates hostname and ID', () => {
+    discovery = new MeshDiscovery();
+    const oid = discovery.meshId;
+    discovery.setLocalName('custom');
+    expect(discovery.hostname).toBe('custom');
+    expect(discovery.meshId).not.toBe(oid);
+    expect(discovery.meshId).toContain('custom');
+  });
+
+  test('startAdvertising sets isSharing true', async () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.isSharing).toBeFalse();
+    await discovery.startAdvertising(9999, '/cwd');
+    expect(discovery.isSharing).toBeTrue();
+  });
+
+  test('stopAdvertising sets isSharing false', async () => {
+    discovery = new MeshDiscovery();
+    await discovery.startAdvertising(9999, '/cwd');
+    discovery.stopAdvertising();
+    expect(discovery.isSharing).toBeFalse();
+  });
+
+  test('startAdvertising idempotent', async () => {
+    discovery = new MeshDiscovery();
+    await discovery.startAdvertising(9999, '/cwd');
+    await discovery.startAdvertising(8888, '/other');
+    expect(discovery.isSharing).toBeTrue();
+  });
+
+  test('stopAdvertising idempotent when not advertising', () => {
+    discovery = new MeshDiscovery();
+    discovery.stopAdvertising();
+    expect(discovery.isSharing).toBeFalse();
+  });
+
+  test('getPeers returns empty initially', () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.getPeers()).toEqual([]);
+  });
+
+  test('getPeer returns undefined for unknown', () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.getPeer('nobody')).toBeUndefined();
+  });
+
+  test('discoverPeers returns array', async () => {
+    discovery = new MeshDiscovery();
+    const peers = await discovery.discoverPeers(100);
+    expect(Array.isArray(peers)).toBeTrue();
+  });
+
+  test('discoverMeshs alias', async () => {
+    discovery = new MeshDiscovery();
+    const peers = await discovery.discoverMeshs(100);
+    expect(Array.isArray(peers)).toBeTrue();
+  });
+
+  test('close stops advertising', () => {
+    discovery = new MeshDiscovery();
+    discovery.close();
+    expect(discovery.isSharing).toBeFalse();
+  });
+
+  test('getGlobalDiscovery singleton', () => {
+    expect(getGlobalDiscovery()).toBe(getGlobalDiscovery());
+  });
+});
+`;
+fs.writeFileSync(p, code, 'utf8');
+console.log('MeshDiscovery.test.ts written');