clew-code 0.2.29 → 0.2.31

package/scripts/codegraph.ts

@@ -0,0 +1,221 @@
+#!/usr/bin/env bun
+/**
+ * Code Graph Generator
+ *
+ * Scans src/ and builds a persistent structure map of the codebase.
+ * Uses ripgrep (fast, available in the project) for text patterns.
+ *
+ * Usage: bun run scripts/codegraph.ts
+ */
+
+import { readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { join, dirname } from 'path'
+import { execSync } from 'child_process'
+
+const ROOT = join(import.meta.dirname, '..')
+const SRC = join(ROOT, 'src')
+const OUT = join(ROOT, '.clew', 'CODEGRAPH.md')
+
+function rg(args: string): string {
+  try {
+    return execSync(`rg ${args}`, { cwd: ROOT, encoding: 'utf-8', timeout: 60000, stdio: ['pipe', 'pipe', 'ignore'] })
+  } catch (e: any) {
+    return e.stdout || ''
+  }
+}
+
+interface Module {
+  path: string
+  lines: number
+  exports: string[]
+  types: string[]
+  classNames: string[]
+  imports: string[]
+  todos: number
+}
+
+// ── 1. File list ──
+console.log('📁 Scanning files...')
+const fileLines = rg('--count --sort path --type ts "^" src/').trim().split('\n').filter(Boolean)
+
+const files = new Map<string, Module>()
+
+for (const entry of fileLines) {
+  const colon = entry.lastIndexOf(':')
+  const relPath = entry.slice(0, colon).replace(/\\/g, '/').replace(/^src\//, '')
+  const lineCount = parseInt(entry.slice(colon + 1)) || 0
+  if (!relPath || relPath.startsWith('..')) continue
+
+  files.set(relPath, {
+    path: relPath,
+    lines: lineCount,
+    exports: [],
+    types: [],
+    classNames: [],
+    imports: [],
+    todos: 0,
+  })
+}
+console.log(`   ${files.size} files`)
+
+// ── 2. Exports via ripgrep (bulk) ──
+console.log('🔍 Exports...')
+
+type Field = 'exports' | 'types' | 'classNames'
+const patterns: { rgPattern: string; field: Field }[] = [
+  { rgPattern: 'export (async )?function [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'exports' },
+  { rgPattern: 'export const [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'exports' },
+  { rgPattern: 'export (abstract )?class [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'classNames' },
+  { rgPattern: 'export interface [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'types' },
+  { rgPattern: 'export type [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'types' },
+]
+
+for (const p of patterns) {
+  // Single rg call per pattern — fast
+  const out = rg(`--with-filename --only-matching --no-line-number "${p.rgPattern}" src/`).trim()
+  for (const line of out.split('\n').filter(Boolean)) {
+    const fileSep = line.indexOf(':')
+    if (fileSep === -1) continue
+    const rawPath = line.slice(0, fileSep).replace(/\\/g, '/').replace(/^src\//, '')
+    const matched = line.slice(fileSep + 1).trim()
+    const name = matched.split(/\s+/).pop()
+    if (!name || !rawPath) continue
+    const f = files.get(rawPath)
+    if (f && !(f[p.field] as string[]).includes(name)) {
+      (f[p.field] as string[]).push(name)
+    }
+  }
+}
+
+// ── 3. Imports + TODOs ──
+console.log('📎 Dependencies...')
+
+for (const [relPath, info] of files) {
+  try {
+    const content = readFileSync(join(SRC, relPath), 'utf-8')
+
+    // Internal imports
+    const srcImports: string[] = []
+    for (const line of content.split('\n')) {
+      const m = line.match(/from\s+['"](src\/[^'"]+)['"]/)
+      if (m) srcImports.push(m[1])
+    }
+    info.imports = [...new Set(srcImports)]
+
+    // TODOs
+    info.todos = (content.match(/\b(TODO|FIXME|HACK|XXX)\b/g) || []).length
+  } catch {
+    // skip unreadable files
+  }
+}
+
+// Also add class names to exports
+for (const f of files.values()) {
+  for (const cls of f.classNames) {
+    if (!f.exports.includes(cls)) f.exports.push(cls)
+  }
+}
+
+// ── 4. Generate markdown ──
+console.log('📝 Generating...')
+
+const totalLines = [...files.values()].reduce((a, f) => a + f.lines, 0)
+const totalExports = [...files.values()].reduce((a, f) => a + f.exports.length, 0)
+const totalTodos = [...files.values()].reduce((a, f) => a + f.todos, 0)
+
+const md: string[] = []
+md.push('# Code Graph')
+md.push('')
+md.push(`_Auto-generated ${new Date().toISOString().slice(0, 10)}_`)
+md.push('')
+md.push(`- **Source files**: ${files.size}`)
+md.push(`- **Total lines**: ${totalLines.toLocaleString()}`)
+md.push(`- **Exports**: ${totalExports}`)
+md.push(`- **TODOs**: ${totalTodos}`)
+md.push('')
+
+// Group by top directory
+const dirMap = new Map<string, Module[]>()
+for (const f of files.values()) {
+  const dir = f.path.split('/')[0]
+  if (!dirMap.has(dir)) dirMap.set(dir, [])
+  dirMap.get(dir)!.push(f)
+}
+
+for (const [dir, dirFiles] of [...dirMap.entries()].sort()) {
+  md.push(`## ${dir}/`)
+  md.push('')
+  dirFiles.sort((a, b) => b.lines - a.lines)
+
+  for (const f of dirFiles) {
+    if (f.lines < 25 && !f.exports.length && !f.types.length) continue
+
+    const badges = [`${f.lines} lines`]
+    if (f.todos) badges.push(`⚠️ ${f.todos}`)
+
+    md.push(`### \`${f.path}\``)
+    md.push(`_${badges.join(', ')}_`)
+
+    if (f.exports.length) {
+      const list = f.exports.slice(0, 10).join(', ')
+      md.push(`- exports: ${list}${f.exports.length > 10 ? ` [+${f.exports.length - 10}]` : ''}`)
+    }
+    if (f.types.length) {
+      const list = f.types.slice(0, 6).join(', ')
+      md.push(`- types: ${list}${f.types.length > 6 ? ` [+${f.types.length - 6}]` : ''}`)
+    }
+    if (f.imports.length) {
+      const list = f.imports.slice(0, 5).join(', ')
+      md.push(`- deps: ${list}${f.imports.length > 5 ? ` (+${f.imports.length - 5})` : ''}`)
+    }
+    md.push('')
+  }
+}
+
+// Hot dependencies
+const depCount = new Map<string, number>()
+for (const f of files.values()) {
+  for (const dep of f.imports) {
+    depCount.set(dep, (depCount.get(dep) || 0) + 1)
+  }
+}
+
+const sortedDeps = [...depCount.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15)
+if (sortedDeps.length) {
+  md.push('---')
+  md.push('## Hot Dependencies')
+  md.push('')
+  for (const [dep, count] of sortedDeps) {
+    md.push(`- \`${dep}\` — imported by ${count} files`)
+  }
+  md.push('')
+}
+
+// Large files
+const largeFiles = [...files.values()].filter(f => f.lines > 300).sort((a, b) => b.lines - a.lines)
+if (largeFiles.length) {
+  md.push('---')
+  md.push('## Large Files (>300 lines)')
+  md.push('')
+  for (const f of largeFiles) {
+    md.push(`- \`${f.path}\` — ${f.lines} lines${f.todos ? ', ⚠️' : ''}`)
+  }
+  md.push('')
+}
+
+// TODO hotspots
+const todoFiles = [...files.values()].filter(f => f.todos > 2).sort((a, b) => b.todos - a.todos).slice(0, 10)
+if (todoFiles.length) {
+  md.push('---')
+  md.push('## TODO Hotspots')
+  md.push('')
+  for (const f of todoFiles) {
+    md.push(`- \`${f.path}\` — ${f.todos} TODOs`)
+  }
+  md.push('')
+}
+
+mkdirSync(dirname(OUT), { recursive: true })
+writeFileSync(OUT, md.join('\n'), 'utf-8')
+console.log(`\n✅ ${OUT}`)
+console.log(`   ${files.size} files | ${totalLines.toLocaleString()} lines | ${totalExports} exports`)

package/scripts/comment-on-duplicates.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+#
+# Comments on a GitHub issue with a list of potential duplicates.
+# Usage: ./comment-on-duplicates.sh --potential-duplicates 456 789 101
+#
+# The base issue number is read from the workflow event payload.
+#
+
+set -euo pipefail
+
+REPO="JonusNattapong/ClaudeCode"
+
+# Read from event payload so the issue number is bound to the triggering event.
+# Falls back to workflow_dispatch inputs for manual runs.
+BASE_ISSUE=$(jq -r '.issue.number // .inputs.issue_number // empty' "${GITHUB_EVENT_PATH:?GITHUB_EVENT_PATH not set}")
+if ! [[ "$BASE_ISSUE" =~ ^[0-9]+$ ]]; then
+  echo "Error: no issue number in event payload" >&2
+  exit 1
+fi
+
+DUPLICATES=()
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --potential-duplicates)
+      shift
+      while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do
+        DUPLICATES+=("$1")
+        shift
+      done
+      ;;
+    *)
+      echo "Error: unknown argument (only --potential-duplicates is accepted)" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validate duplicates
+if [[ ${#DUPLICATES[@]} -eq 0 ]]; then
+  echo "Error: --potential-duplicates requires at least one issue number" >&2
+  exit 1
+fi
+
+if [[ ${#DUPLICATES[@]} -gt 3 ]]; then
+  echo "Error: --potential-duplicates accepts at most 3 issues" >&2
+  exit 1
+fi
+
+for dup in "${DUPLICATES[@]}"; do
+  if ! [[ "$dup" =~ ^[0-9]+$ ]]; then
+    echo "Error: duplicate issue must be a number, got: $dup" >&2
+    exit 1
+  fi
+done
+
+# Validate that base issue exists
+if ! gh issue view "$BASE_ISSUE" --repo "$REPO" &>/dev/null; then
+  echo "Error: issue #$BASE_ISSUE does not exist in $REPO" >&2
+  exit 1
+fi
+
+# Validate that all duplicate issues exist
+for dup in "${DUPLICATES[@]}"; do
+  if ! gh issue view "$dup" --repo "$REPO" &>/dev/null; then
+    echo "Error: issue #$dup does not exist in $REPO" >&2
+    exit 1
+  fi
+done
+
+# Build comment body
+COUNT=${#DUPLICATES[@]}
+if [[ $COUNT -eq 1 ]]; then
+  HEADER="Found 1 possible duplicate issue:"
+else
+  HEADER="Found $COUNT possible duplicate issues:"
+fi
+
+BODY="$HEADER"$'\n\n'
+INDEX=1
+for dup in "${DUPLICATES[@]}"; do
+  BODY+="$INDEX. https://github.com/$REPO/issues/$dup"$'\n'
+  ((INDEX++))
+done
+
+BODY+=$'\n'"This issue will be automatically closed as a duplicate in 3 days."$'\n\n'
+BODY+="- If your issue is a duplicate, please close it and 👍 the existing issue instead"$'\n'
+BODY+="- To prevent auto-closure, add a comment or 👎 this comment"$'\n\n'
+BODY+="🤖 Generated with [Claude Code](https://claude.ai/code)"
+
+# Post the comment
+gh issue comment "$BASE_ISSUE" --repo "$REPO" --body "$BODY"
+
+echo "Posted duplicate comment on issue #$BASE_ISSUE"

package/scripts/edit-issue-labels.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+#
+# Edits labels on a GitHub issue.
+# Usage: ./edit-issue-labels.sh --add-label bug --add-label needs-triage --remove-label untriaged
+#
+# The issue number is read from the workflow event payload.
+#
+
+set -euo pipefail
+
+# Read from event payload so the issue number is bound to the triggering event.
+# Falls back to workflow_dispatch inputs for manual runs.
+ISSUE=$(jq -r '.issue.number // .inputs.issue_number // empty' "${GITHUB_EVENT_PATH:?GITHUB_EVENT_PATH not set}")
+if ! [[ "$ISSUE" =~ ^[0-9]+$ ]]; then
+  echo "Error: no issue number in event payload" >&2
+  exit 1
+fi
+
+ADD_LABELS=()
+REMOVE_LABELS=()
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --add-label)
+      ADD_LABELS+=("$2")
+      shift 2
+      ;;
+    --remove-label)
+      REMOVE_LABELS+=("$2")
+      shift 2
+      ;;
+    *)
+      echo "Error: unknown argument (only --add-label and --remove-label are accepted)" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [[ ${#ADD_LABELS[@]} -eq 0 && ${#REMOVE_LABELS[@]} -eq 0 ]]; then
+  exit 1
+fi
+
+# Fetch valid labels from the repo
+VALID_LABELS=$(gh label list --limit 500 --json name --jq '.[].name')
+
+# Filter to only labels that exist in the repo
+FILTERED_ADD=()
+for label in "${ADD_LABELS[@]}"; do
+  if echo "$VALID_LABELS" | grep -qxF "$label"; then
+    FILTERED_ADD+=("$label")
+  fi
+done
+
+FILTERED_REMOVE=()
+for label in "${REMOVE_LABELS[@]}"; do
+  if echo "$VALID_LABELS" | grep -qxF "$label"; then
+    FILTERED_REMOVE+=("$label")
+  fi
+done
+
+if [[ ${#FILTERED_ADD[@]} -eq 0 && ${#FILTERED_REMOVE[@]} -eq 0 ]]; then
+  exit 0
+fi
+
+# Build gh command arguments
+GH_ARGS=("issue" "edit" "$ISSUE")
+
+for label in "${FILTERED_ADD[@]}"; do
+  GH_ARGS+=("--add-label" "$label")
+done
+
+for label in "${FILTERED_REMOVE[@]}"; do
+  GH_ARGS+=("--remove-label" "$label")
+done
+
+gh "${GH_ARGS[@]}"
+
+if [[ ${#FILTERED_ADD[@]} -gt 0 ]]; then
+  echo "Added: ${FILTERED_ADD[*]}"
+fi
+if [[ ${#FILTERED_REMOVE[@]} -gt 0 ]]; then
+  echo "Removed: ${FILTERED_REMOVE[*]}"
+fi

package/scripts/final-peer-rename.mjs

@@ -0,0 +1,46 @@
+const fs = require('fs');
+const path = require('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()) {
+      if (!e.name.startsWith('.') && e.name !== 'node_modules' && e.name !== 'dist') r.push(...walk(f));
+    } else if (e.name.endsWith('.ts') || e.name.endsWith('.tsx')) r.push(f);
+  }
+  return r;
+}
+
+const files = walk('src');
+let count = 0;
+for (const f of files) {
+  let c = fs.readFileSync(f, 'utf-8');
+  const orig = c;
+
+  c = c.replace(/\/peer\//g, '/swarm/');
+  c = c.replace(/\bPeer(Broadcast|Disconnect|Discover|Join|ListMessages|ListRoles|Ping|Run|SendMessage|SetName|SetRole|Share|Spawn|Info|Help|Server|Store|Discovery|StatusLine|Type)Tool\b/g, 'Swarm$1Tool');
+  c = c.replace(/\bPeer(Broadcast|Disconnect|Discover|Join|ListMessages|ListRoles|Ping|Run|SendMessage|SetName|SetRole|Share|Spawn|Info|Help|Server|Store|Discovery|StatusLine|Type)\b/g, 'Swarm$1');
+  c = c.replace(/\bProcessPeer(Provider|Tool)/g, 'ProcessSwarm$1');
+  c = c.replace(/\bCodexPeer/g, 'CodexSwarm');
+  c = c.replace(/\bgetProcessPeerProvider\b/g, 'getProcessSwarmProvider');
+  c = c.replace(/\bgetProcessPeerProviderIds\b/g, 'getProcessSwarmProviderIds');
+  c = c.replace(/\bmyPeerId\b/g, 'mySwarmId');
+  c = c.replace(/\bpeerId\b/g, 'swarmId');
+  c = c.replace(/\bPEER_(\w+)_TOOL_NAME\b/g, 'SWARM_$1_TOOL_NAME');
+  c = c.replace(/\bpeer(Server|Store|Discovery|Port|Name|Info|List|Count|Connection|Sharing|Health)\b/g, 'swarm$1');
+  c = c.replace(/\bgetGlobalPeer(Server|Store)\b/g, 'getGlobalSwarm$1');
+  c = c.replace(/\bnotifyPeerFeedback\b/g, 'notifySwarmFeedback');
+  c = c.replace(/\bsetPeerFeedbackHandler\b/g, 'setSwarmFeedbackHandler');
+  c = c.replace(/\bPeerFeedback\b/g, 'SwarmFeedback');
+  c = c.replace(/\bpeer-feedback/g, 'swarm-feedback');
+  c = c.replace(/\bpeerFeedback/g, 'swarmFeedback');
+  c = c.replace(/\/peer\b/g, '/swarm');
+  c = c.replace(/['"]peer-/g, (m) => m.replace('peer-', 'swarm-'));
+  c = c.replace(/\bspawnPeerTerminal\b/g, 'spawnSwarmTerminal');
+  c = c.replace(/\bparseProcessPeerRunArgs\b/g, 'parseProcessSwarmRunArgs');
+  c = c.replace(/\bProcessPeerRunArgs\b/g, 'ProcessSwarmRunArgs');
+
+  if (c !== orig) { fs.writeFileSync(f, c, 'utf-8'); count++; }
+}
+console.log('Updated:', count, 'files');

package/scripts/fix-encoding.mjs

@@ -0,0 +1,83 @@
+/**
+ * Fix mojibake encoding in all docs HTML files.
+ *
+ * Problem: Files were double-encoded — original UTF-8 bytes were
+ * misinterpreted as CP1252 then re-encoded as UTF-8, producing
+ * characters like — instead of — and ค instead of ค.
+ *
+ * This script reverses the damage by mapping each Unicode char
+ * back to its CP1252 byte and re-decoding as UTF-8.
+ * Legitimate Unicode characters (Thai, arrows, emoji) pass through.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+const cp1252 = new Map([
+  [0x20ac, 0x80], [0x201a, 0x82], [0x0192, 0x83], [0x201e, 0x84],
+  [0x2026, 0x85], [0x2020, 0x86], [0x2021, 0x87], [0x02c6, 0x88],
+  [0x2030, 0x89], [0x0160, 0x8a], [0x2039, 0x8b], [0x0152, 0x8c],
+  [0x017d, 0x8e], [0x2018, 0x91], [0x2019, 0x92], [0x201c, 0x93],
+  [0x201d, 0x94], [0x2022, 0x95], [0x2013, 0x96], [0x2014, 0x97],
+  [0x02dc, 0x98], [0x2122, 0x99], [0x0161, 0x9a], [0x203a, 0x9b],
+  [0x0153, 0x9c], [0x017e, 0x9e], [0x0178, 0x9f],
+]);
+
+function fixMojibake(text) {
+  if (text.charCodeAt(0) === 0xfeff) text = text.slice(1); // strip BOM
+
+  const bytes = [];
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code <= 0xff) {
+      bytes.push(code);
+    } else if (cp1252.has(code)) {
+      bytes.push(cp1252.get(code));
+    } else {
+      const buf = Buffer.from(text[i], 'utf-8');
+      for (const b of buf) bytes.push(b);
+    }
+  }
+  return Buffer.from(bytes).toString('utf-8');
+}
+
+// Walk docs/ recursively
+function walk(dir) {
+  const results = [];
+  const list = fs.readdirSync(dir);
+  for (const entry of list) {
+    const full = path.join(dir, entry);
+    const stat = fs.statSync(full);
+    if (stat.isDirectory()) {
+      results.push(...walk(full));
+    } else if (entry.endsWith('.html')) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+const files = walk('docs');
+let changed = 0;
+let errors = 0;
+
+for (const f of files) {
+  try {
+    const content = fs.readFileSync(f, 'utf-8');
+    const fixed = fixMojibake(content);
+
+    // skip if no change
+    if (fixed === content) {
+      console.log(`  ✓  ${f} — already clean`);
+      continue;
+    }
+
+    fs.writeFileSync(f, fixed, 'utf-8');
+    console.log(`  ✔  ${f}`);
+    changed++;
+  } catch (err) {
+    console.error(`  ✘  ${f}: ${err.message}`);
+    errors++;
+  }
+}
+
+console.log(`\nDone: ${changed} files fixed, ${errors} errors`);

package/scripts/fix-inconsistencies.mjs

@@ -0,0 +1,67 @@
+/**
+ * Normalize all HTML files to consistent structure:
+ * - Empty header (JS-injected)
+ * - main.js script at end of body
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const docsDir = path.resolve(__dirname, '../docs');
+
+function walk(dir) {
+  const results = [];
+  const list = fs.readdirSync(dir);
+  for (const entry of list) {
+    const full = path.join(dir, entry);
+    const stat = fs.statSync(full);
+    if (stat.isDirectory()) results.push(...walk(full));
+    else if (entry.endsWith('.html')) results.push(full);
+  }
+  return results;
+}
+
+function relativePath(from, to) {
+  const rel = path.relative(path.dirname(from), to);
+  return rel.startsWith('.') ? rel : './' + rel;
+}
+
+const files = walk(docsDir);
+let fixed = 0;
+
+for (const filePath of files) {
+  let c = fs.readFileSync(filePath, 'utf-8');
+  const name = path.basename(filePath);
+
+  // Skip landing page (different structure by design)
+  if (name === 'index.html' || name === 'index.th.html') continue;
+
+  // Fix 1: Replace inline header with empty header
+  if (!c.includes('<header class="header"></header>')) {
+    c = c.replace(/<header class="header">[\s\S]*?<\/header>\s*/,
+      '<header class="header"></header>\n');
+  }
+
+  // Fix 2: Add main.js if missing
+  if (!c.includes('main.js')) {
+    const jsRelPath = relativePath(filePath, path.join(docsDir, 'js/main.js'));
+    c = c.replace('</body>', `<script src="${jsRelPath}"></script>\n</body>`);
+  }
+
+  // Fix 3: Ensure Google Fonts includes Noto Sans Thai for .th.html files
+  if (name.endsWith('.th.html') && !c.includes('Noto+Sans+Thai')) {
+    c = c.replace(
+      /family=JetBrains\+Mono:[^"'&]+/,
+      '$&, &family=Noto+Sans+Thai:wght@400;500;600;700'
+    );
+  }
+
+  // Fix 4: Clean up old lang-wrap styles in features/internals
+  c = c.replace(/<div class="lang-wrap">[\s\S]*?<\/div>\s*<\/div>\s*/, '');
+
+  fs.writeFileSync(filePath, c, 'utf-8');
+  fixed++;
+}
+
+console.log(`Normalized ${fixed} files`);