claws-code 0.8.0

package/scripts/dev-hooks/check-extension-dirs.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// SessionStart hook: warn if multiple neunaha.claws-* extension dirs exist OR
+// if the active extension's package.json has invalid semver.
+// Always exits 0 — warnings only. Timeout < 5s. Logs misfires to /tmp/claws-dev-hooks.log.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const LOG = '/tmp/claws-dev-hooks.log';
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+
+function log(msg) {
+  const ts = new Date().toISOString();
+  try { fs.appendFileSync(LOG, `${ts} [check-extension-dirs] ${msg}\n`); } catch (_) {}
+}
+
+function main() {
+  const extRoot = path.join(process.env.HOME || process.env.USERPROFILE || '', '.vscode', 'extensions');
+  let entries = [];
+  try { entries = fs.readdirSync(extRoot); } catch (_) { return; } // no vscode dir
+
+  const clawsDirs = entries.filter((e) => e.startsWith('neunaha.claws-'));
+
+  if (clawsDirs.length > 1) {
+    console.warn(
+      `\n⚠️  [claws-dev-hook] Multiple Claws extension dirs detected:\n` +
+      clawsDirs.map((d) => `   ${path.join(extRoot, d)}`).join('\n') + '\n' +
+      `   Remove old versions: rm -rf ~/.vscode/extensions/neunaha.claws-<old>\n` +
+      `   Reload VS Code after removal (Cmd+Shift+P → Developer: Reload Window)\n`
+    );
+  }
+
+  // Validate semver on the newest dir
+  const sorted = clawsDirs
+    .map((d) => ({ dir: d, ver: d.replace('neunaha.claws-', '') }))
+    .filter((x) => SEMVER_RE.test(x.ver))
+    .sort((a, b) => {
+      const [am, an, ap] = a.ver.split('.').map(Number);
+      const [bm, bn, bp] = b.ver.split('.').map(Number);
+      return bm - am || bn - an || bp - ap;
+    });
+
+  if (sorted.length === 0 && clawsDirs.length > 0) {
+    const badDirs = clawsDirs.filter((d) => !SEMVER_RE.test(d.replace('neunaha.claws-', '')));
+    if (badDirs.length > 0) {
+      console.warn(
+        `\n⚠️  [claws-dev-hook] Extension dir(s) with invalid semver: ${badDirs.join(', ')}\n` +
+        `   Expected format: neunaha.claws-MAJOR.MINOR.PATCH\n`
+      );
+      log(`invalid semver dirs: ${badDirs.join(', ')}`);
+    }
+    return;
+  }
+
+  if (sorted.length > 0) {
+    const newest = path.join(extRoot, sorted[0].dir);
+    let pkgVer = '';
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(newest, 'package.json'), 'utf8'));
+      pkgVer = pkg.version || '';
+    } catch (e) {
+      log(`package.json read failed for ${newest}: ${e.message}`);
+      return;
+    }
+    if (!SEMVER_RE.test(pkgVer)) {
+      console.warn(
+        `\n⚠️  [claws-dev-hook] Extension manifest version "${pkgVer}" is not valid semver.\n` +
+        `   Expected: MAJOR.MINOR.PATCH (e.g. 0.7.7)\n`
+      );
+      log(`invalid manifest version: ${pkgVer} in ${newest}`);
+    }
+  }
+}
+
+try { main(); } catch (e) { log(`uncaught: ${e.message}`); }
+process.exit(0);

package/scripts/dev-hooks/check-open-claws-terminals.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// Stop hook: list open wrapped terminals via raw socket; warn if >0 remain open.
+// Always exits 0 — warnings only. Timeout < 5s. Logs misfires to /tmp/claws-dev-hooks.log.
+'use strict';
+
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+
+const LOG = '/tmp/claws-dev-hooks.log';
+
+function log(msg) {
+  const ts = new Date().toISOString();
+  try { fs.appendFileSync(LOG, `${ts} [check-open-claws-terminals] ${msg}\n`); } catch (_) {}
+}
+
+function findSock() {
+  if (process.env.CLAWS_SOCKET) return process.env.CLAWS_SOCKET;
+  let d = process.env.PROJECT_ROOT || process.cwd();
+  for (let i = 0; i < 20 && d && d !== '/'; i++) {
+    const candidate = path.join(d, '.claws', 'claws.sock');
+    try { if (fs.statSync(candidate).isSocket()) return candidate; } catch (_) {}
+    d = path.dirname(d);
+  }
+  return null;
+}
+
+function listTerminals(sockPath) {
+  return new Promise((resolve) => {
+    const s = net.createConnection(sockPath);
+    const timer = setTimeout(() => { s.destroy(); resolve([]); }, 4000);
+    s.on('connect', () => s.write(JSON.stringify({ id: 1, cmd: 'list' }) + '\n'));
+    let buf = '';
+    s.on('data', (d) => {
+      buf += d;
+      const nl = buf.indexOf('\n');
+      if (nl !== -1) {
+        clearTimeout(timer);
+        try {
+          const parsed = JSON.parse(buf.slice(0, nl));
+          resolve(parsed.terminals || []);
+        } catch (_) { resolve([]); }
+        s.destroy();
+      }
+    });
+    s.on('error', () => { clearTimeout(timer); resolve([]); });
+  });
+}
+
+async function main() {
+  const sockPath = findSock();
+  if (!sockPath) return; // no socket — not a Claws session
+
+  let terminals = [];
+  try { terminals = await listTerminals(sockPath); } catch (e) {
+    log(`list failed: ${e.message}`);
+    return;
+  }
+
+  const wrapped = terminals.filter((t) => t.logPath || t.wrapped);
+  if (wrapped.length > 0) {
+    const names = wrapped.map((t) => `#${t.id} ${t.name || '(unnamed)'}`).join(', ');
+    console.warn(
+      `\n⚠️  [claws-dev-hook] ${wrapped.length} wrapped terminal(s) still open: ${names}\n` +
+      `   Close them before ending your session to avoid stale pty logs.\n`
+    );
+  }
+}
+
+main().catch((e) => log(`uncaught: ${e.message}`)).then(() => process.exit(0));

package/scripts/dev-hooks/check-stale-main.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// SessionStart hook: warn if local main/current branch is behind origin.
+// Always exits 0 — warnings only. Timeout < 5s. Logs misfires to /tmp/claws-dev-hooks.log.
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const LOG = '/tmp/claws-dev-hooks.log';
+
+function log(msg) {
+  const ts = new Date().toISOString();
+  try { fs.appendFileSync(LOG, `${ts} [check-stale-main] ${msg}\n`); } catch (_) {}
+}
+
+function run(cmd, opts = {}) {
+  return execSync(cmd, { timeout: 4000, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], ...opts }).trim();
+}
+
+function main() {
+  const cwd = process.env.PROJECT_ROOT || process.cwd();
+
+  // Not a git repo — skip silently
+  try { run('git rev-parse --git-dir', { cwd }); } catch (_) { return; }
+
+  // Fetch with a tight timeout; if offline, exit silently
+  try {
+    run('git fetch origin --quiet --no-tags --depth=1', { cwd, timeout: 4000 });
+  } catch (e) {
+    log(`fetch failed (offline?): ${e.message}`);
+    return;
+  }
+
+  let behind = 0;
+  try {
+    const branch = run('git rev-parse --abbrev-ref HEAD', { cwd });
+    const upstream = `origin/${branch}`;
+    const count = run(`git rev-list --count HEAD..${upstream}`, { cwd });
+    behind = parseInt(count, 10) || 0;
+  } catch (e) {
+    log(`rev-list failed: ${e.message}`);
+    return;
+  }
+
+  if (behind > 0) {
+    console.warn(
+      `\n⚠️  [claws-dev-hook] Your branch is ${behind} commit(s) behind origin.\n` +
+      `   Run: git pull --ff-only origin\n`
+    );
+  }
+}
+
+try { main(); } catch (e) { log(`uncaught: ${e.message}`); }
+process.exit(0);

package/scripts/dev-hooks/check-tag-pushed.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// PostToolUse Bash hook (git push): verify the latest local tag exists on origin.
+// Always exits 0 — warnings only. Timeout < 5s. Logs misfires to /tmp/claws-dev-hooks.log.
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+
+const LOG = '/tmp/claws-dev-hooks.log';
+
+function log(msg) {
+  const ts = new Date().toISOString();
+  try { fs.appendFileSync(LOG, `${ts} [check-tag-pushed] ${msg}\n`); } catch (_) {}
+}
+
+function run(cmd, opts = {}) {
+  return execSync(cmd, { timeout: 4000, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], ...opts }).trim();
+}
+
+function main() {
+  const cwd = process.env.PROJECT_ROOT || process.cwd();
+
+  // Not a git repo — skip silently
+  try { run('git rev-parse --git-dir', { cwd }); } catch (_) { return; }
+
+  let latestTag = '';
+  try {
+    latestTag = run('git describe --tags --abbrev=0', { cwd });
+  } catch (_) {
+    return; // no tags yet — skip
+  }
+
+  let remoteTags = '';
+  try {
+    remoteTags = run(`git ls-remote --tags origin refs/tags/${latestTag}`, { cwd, timeout: 4000 });
+  } catch (e) {
+    log(`ls-remote failed: ${e.message}`);
+    return;
+  }
+
+  if (!remoteTags.includes(latestTag)) {
+    console.warn(
+      `\n⚠️  [claws-dev-hook] Local tag ${latestTag} is NOT on origin.\n` +
+      `   Run: git push origin ${latestTag}\n` +
+      `   Or:  git push --tags\n`
+    );
+  }
+}
+
+try { main(); } catch (e) { log(`uncaught: ${e.message}`); }
+process.exit(0);

package/scripts/dev-hooks/check-tag-vs-main.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+// PostToolUse Bash hook (git commit): warn if commits on main are past the last tag.
+// Always exits 0 — warnings only. Timeout < 5s. Logs misfires to /tmp/claws-dev-hooks.log.
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+
+const LOG = '/tmp/claws-dev-hooks.log';
+
+function log(msg) {
+  const ts = new Date().toISOString();
+  try { fs.appendFileSync(LOG, `${ts} [check-tag-vs-main] ${msg}\n`); } catch (_) {}
+}
+
+function run(cmd, opts = {}) {
+  return execSync(cmd, { timeout: 4000, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], ...opts }).trim();
+}
+
+function main() {
+  const cwd = process.env.PROJECT_ROOT || process.cwd();
+
+  // Not a git repo — skip silently
+  try { run('git rev-parse --git-dir', { cwd }); } catch (_) { return; }
+
+  let latestTag = '';
+  try {
+    latestTag = run('git describe --tags --abbrev=0', { cwd });
+  } catch (_) {
+    return; // no tags yet
+  }
+
+  let aheadCount = 0;
+  try {
+    const count = run(`git rev-list --count ${latestTag}..HEAD`, { cwd });
+    aheadCount = parseInt(count, 10) || 0;
+  } catch (e) {
+    log(`rev-list failed: ${e.message}`);
+    return;
+  }
+
+  if (aheadCount > 0) {
+    // Check if we're on main/master
+    let branch = '';
+    try { branch = run('git rev-parse --abbrev-ref HEAD', { cwd }); } catch (_) {}
+    if (branch === 'main' || branch === 'master') {
+      console.warn(
+        `\n⚠️  [claws-dev-hook] ${aheadCount} commit(s) on ${branch} past last tag (${latestTag}).\n` +
+        `   Remember to tag your release: git tag vX.Y.Z && git push --tags\n`
+      );
+    }
+  }
+}
+
+try { main(); } catch (e) { log(`uncaught: ${e.message}`); }
+process.exit(0);

package/scripts/dev-vsix-install.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# scripts/dev-vsix-install.sh
+#
+# Rebuild + repackage + reinstall the Claws extension as a fresh VSIX —
+# the missing dev-loop step that complements `npm run deploy:dev`.
+#
+# Why both exist:
+#   deploy:dev (fast, ~5s)  — copies new dist into installed dir; does NOT
+#                              refresh extensions.json metadata. Panel keeps
+#                              showing original VSIX date — silent staleness risk.
+#   dev-vsix-install (~25s) — full vsce package + code --install-extension.
+#                              Refreshes installedTimestamp, version label, and
+#                              panel date. Use after material extension changes
+#                              or whenever you want a clean dev-install.
+#
+# After this finishes: Cmd+Shift+P → Developer: Reload Window.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+EXT_DIR="$REPO_ROOT/extension"
+VSIX_OUT="${TMPDIR:-/tmp}/claws-dev-$(date +%s).vsix"
+
+[ -d "$EXT_DIR" ] || { echo "[dev-vsix-install] FATAL: $EXT_DIR not found" >&2; exit 1; }
+
+# Resolve the VS Code CLI. Mirrors install.sh::_find_editor_cli — PATH first,
+# then macOS app-bundle fallback. Lets the script work from worker terminals
+# whose PATH may not include /usr/local/bin.
+_find_code_cli() {
+  command -v code 2>/dev/null && return 0
+  case "$(uname -s)" in
+    Darwin)
+      local p="/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code"
+      [ -x "$p" ] && echo "$p" && return 0
+      ;;
+  esac
+  return 1
+}
+CODE_CLI="$(_find_code_cli)" || {
+  echo "[dev-vsix-install] FATAL: 'code' CLI not found" >&2
+  echo "[dev-vsix-install]   tried: PATH, /Applications/Visual Studio Code.app/Contents/Resources/app/bin/code" >&2
+  echo "[dev-vsix-install]   install via VS Code: Cmd+Shift+P -> 'Shell Command: Install code in PATH'" >&2
+  exit 1
+}
+
+echo "[dev-vsix-install] step 1/3 — rebuilding extension"
+( cd "$EXT_DIR" && npm run build )
+
+echo "[dev-vsix-install] step 2/3 — packaging VSIX → $VSIX_OUT"
+( cd "$EXT_DIR" && npx -y @vscode/vsce package \
+    --skip-license --no-git-tag-version --no-update-package-json \
+    --out "$VSIX_OUT" )
+
+echo "[dev-vsix-install] step 3/3 — installing into VS Code via $CODE_CLI"
+"$CODE_CLI" --install-extension "$VSIX_OUT" --force
+echo
+echo "[dev-vsix-install] install complete — reload required:"
+echo "[dev-vsix-install]    Cmd+Shift+P -> Developer: Reload Window"
+echo "[dev-vsix-install] vsix kept at: $VSIX_OUT"