@poolzin/pool-bot 2026.1.38 → 2026.2.0

package/scripts/postinstall.js

@@ -1,300 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { setupGitHooks } from "./setup-git-hooks.js";
-
-function detectPackageManager(ua = process.env.npm_config_user_agent ?? "") {
-  // Examples:
-  // - "pnpm/10.23.0 npm/? node/v22.21.1 darwin arm64"
-  // - "npm/10.9.4 node/v22.12.0 linux x64"
-  // - "bun/1.2.2"
-  const normalized = String(ua).trim();
-  if (normalized.startsWith("pnpm/")) return "pnpm";
-  if (normalized.startsWith("bun/")) return "bun";
-  if (normalized.startsWith("npm/")) return "npm";
-  if (normalized.startsWith("yarn/")) return "yarn";
-  return "unknown";
-}
-
-function shouldApplyPnpmPatchedDependenciesFallback(pm = detectPackageManager()) {
-  // pnpm already applies pnpm.patchedDependencies itself; re-applying would fail.
-  return pm !== "pnpm";
-}
-
-function getRepoRoot() {
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  return path.resolve(here, "..");
-}
-
-function ensureExecutable(targetPath) {
-  if (process.platform === "win32") return;
-  if (!fs.existsSync(targetPath)) return;
-  try {
-    const mode = fs.statSync(targetPath).mode & 0o777;
-    if (mode & 0o100) return;
-    fs.chmodSync(targetPath, 0o755);
-  } catch (err) {
-    console.warn(`[postinstall] chmod failed: ${err}`);
-  }
-}
-
-function hasGit(repoRoot) {
-  const result = spawnSync("git", ["--version"], { cwd: repoRoot, stdio: "ignore" });
-  return result.status === 0;
-}
-
-function extractPackageName(key) {
-  if (key.startsWith("@")) {
-    const idx = key.indexOf("@", 1);
-    if (idx === -1) return key;
-    return key.slice(0, idx);
-  }
-  const idx = key.lastIndexOf("@");
-  if (idx <= 0) return key;
-  return key.slice(0, idx);
-}
-
-function stripPrefix(p) {
-  if (p.startsWith("a/") || p.startsWith("b/")) return p.slice(2);
-  return p;
-}
-
-function parseRange(segment) {
-  // segment: "-12,5" or "+7"
-  const [startRaw, countRaw] = segment.slice(1).split(",");
-  const start = Number.parseInt(startRaw, 10);
-  const count = countRaw ? Number.parseInt(countRaw, 10) : 1;
-  if (Number.isNaN(start) || Number.isNaN(count)) {
-    throw new Error(`invalid hunk range: ${segment}`);
-  }
-  return { start, count };
-}
-
-function parsePatch(patchText) {
-  const lines = patchText.split("\n");
-  const files = [];
-  let i = 0;
-
-  while (i < lines.length) {
-    if (!lines[i].startsWith("diff --git ")) {
-      i += 1;
-      continue;
-    }
-
-    const file = { oldPath: null, newPath: null, hunks: [] };
-    i += 1;
-
-    // Skip index line(s)
-    while (i < lines.length && lines[i].startsWith("index ")) i += 1;
-
-    if (i < lines.length && lines[i].startsWith("--- ")) {
-      file.oldPath = stripPrefix(lines[i].slice(4).trim());
-      i += 1;
-    }
-    if (i < lines.length && lines[i].startsWith("+++ ")) {
-      file.newPath = stripPrefix(lines[i].slice(4).trim());
-      i += 1;
-    }
-
-    while (i < lines.length && lines[i].startsWith("@@")) {
-      const header = lines[i];
-      const match = /^@@\s+(-\d+(?:,\d+)?)\s+(\+\d+(?:,\d+)?)\s+@@/.exec(header);
-      if (!match) throw new Error(`invalid hunk header: ${header}`);
-      const oldRange = parseRange(match[1]);
-      const newRange = parseRange(match[2]);
-      i += 1;
-
-      const hunkLines = [];
-      while (i < lines.length) {
-        const line = lines[i];
-        if (line.startsWith("@@") || line.startsWith("diff --git ")) break;
-        if (line === "") {
-          i += 1;
-          continue;
-        }
-        if (line.startsWith("\")) {
-          i += 1;
-          continue;
-        }
-        hunkLines.push(line);
-        i += 1;
-      }
-
-      file.hunks.push({
-        oldStart: oldRange.start,
-        oldLines: oldRange.count,
-        newStart: newRange.start,
-        newLines: newRange.count,
-        lines: hunkLines,
-      });
-    }
-
-    if (file.newPath && file.hunks.length > 0) {
-      files.push(file);
-    }
-  }
-
-  return files;
-}
-
-function readFileLines(targetPath) {
-  if (!fs.existsSync(targetPath)) {
-    throw new Error(`target file missing: ${targetPath}`);
-  }
-  const raw = fs.readFileSync(targetPath, "utf-8");
-  const hasTrailingNewline = raw.endsWith("\n");
-  const parts = raw.split("\n");
-  if (hasTrailingNewline) parts.pop();
-  return { lines: parts, hasTrailingNewline };
-}
-
-function writeFileLines(targetPath, lines, hadTrailingNewline) {
-  const content = lines.join("\n") + (hadTrailingNewline ? "\n" : "");
-  fs.writeFileSync(targetPath, content, "utf-8");
-}
-
-function applyHunk(lines, hunk, offset) {
-  let cursor = hunk.oldStart - 1 + offset;
-  const expected = [];
-  for (const raw of hunk.lines) {
-    const marker = raw[0];
-    if (marker === " " || marker === "+") {
-      expected.push(raw.slice(1));
-    }
-  }
-  if (cursor >= 0 && cursor + expected.length <= lines.length) {
-    let alreadyApplied = true;
-    for (let i = 0; i < expected.length; i += 1) {
-      if (lines[cursor + i] !== expected[i]) {
-        alreadyApplied = false;
-        break;
-      }
-    }
-    if (alreadyApplied) {
-      const delta = hunk.newLines - hunk.oldLines;
-      return offset + delta;
-    }
-  }
-
-  for (const raw of hunk.lines) {
-    const marker = raw[0];
-    const text = raw.slice(1);
-    if (marker === " ") {
-      if (lines[cursor] !== text) {
-        throw new Error(
-          `context mismatch at line ${cursor + 1}: expected "${text}", found "${lines[cursor] ?? "<eof>"}"`,
-        );
-      }
-      cursor += 1;
-    } else if (marker === "-") {
-      if (lines[cursor] !== text) {
-        throw new Error(
-          `delete mismatch at line ${cursor + 1}: expected "${text}", found "${lines[cursor] ?? "<eof>"}"`,
-        );
-      }
-      lines.splice(cursor, 1);
-    } else if (marker === "+") {
-      lines.splice(cursor, 0, text);
-      cursor += 1;
-    } else {
-      throw new Error(`unexpected hunk marker: ${marker}`);
-    }
-  }
-
-  const delta = hunk.newLines - hunk.oldLines;
-  return offset + delta;
-}
-
-function applyPatchToFile(targetDir, filePatch) {
-  if (filePatch.newPath === "/dev/null") {
-    // deletion not needed for our patches
-    return;
-  }
-  const relPath = stripPrefix(filePatch.newPath ?? filePatch.oldPath ?? "");
-  const targetPath = path.join(targetDir, relPath);
-  const { lines, hasTrailingNewline } = readFileLines(targetPath);
-
-  let offset = 0;
-  for (const hunk of filePatch.hunks) {
-    offset = applyHunk(lines, hunk, offset);
-  }
-
-  writeFileLines(targetPath, lines, hasTrailingNewline);
-}
-
-function applyPatchSet({ patchText, targetDir }) {
-  let resolvedTarget = path.resolve(targetDir);
-  if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isDirectory()) {
-    console.warn(`[postinstall] skip missing target: ${resolvedTarget}`);
-    return;
-  }
-  resolvedTarget = fs.realpathSync(resolvedTarget);
-
-  const files = parsePatch(patchText);
-  if (files.length === 0) return;
-
-  for (const filePatch of files) {
-    applyPatchToFile(resolvedTarget, filePatch);
-  }
-}
-
-function applyPatchFile({ patchPath, targetDir }) {
-  const absPatchPath = path.resolve(patchPath);
-  if (!fs.existsSync(absPatchPath)) {
-    throw new Error(`missing patch: ${absPatchPath}`);
-  }
-  const patchText = fs.readFileSync(absPatchPath, "utf-8");
-  applyPatchSet({ patchText, targetDir });
-}
-
-function main() {
-  const repoRoot = getRepoRoot();
-  process.chdir(repoRoot);
-
-  ensureExecutable(path.join(repoRoot, "dist", "entry.js"));
-  setupGitHooks({ repoRoot });
-
-  if (!shouldApplyPnpmPatchedDependenciesFallback()) {
-    return;
-  }
-
-  const pkgPath = path.join(repoRoot, "package.json");
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-  const patched = pkg?.pnpm?.patchedDependencies ?? {};
-
-  // Bun does not support pnpm.patchedDependencies. Apply these patch files to
-  // node_modules packages as a best-effort compatibility layer.
-  for (const [key, relPatchPath] of Object.entries(patched)) {
-    if (typeof relPatchPath !== "string" || !relPatchPath.trim()) continue;
-    const pkgName = extractPackageName(String(key));
-    if (!pkgName) continue;
-    applyPatchFile({
-      targetDir: path.join("node_modules", ...pkgName.split("/")),
-      patchPath: relPatchPath,
-    });
-  }
-}
-
-try {
-  const skip =
-    process.env.CLAWDBOT_SKIP_POSTINSTALL === "1" ||
-    process.env.VITEST === "true" ||
-    process.env.NODE_ENV === "test";
-
-  if (!skip) {
-    main();
-  }
-} catch (err) {
-  console.error(String(err));
-  process.exit(1);
-}
-
-export {
-  applyPatchFile,
-  applyPatchSet,
-  applyPatchToFile,
-  detectPackageManager,
-  parsePatch,
-  shouldApplyPnpmPatchedDependenciesFallback,
-};

package/scripts/setup-git-hooks.js

@@ -1,96 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-const DEFAULT_HOOKS_PATH = "git-hooks";
-const PRE_COMMIT_HOOK = "pre-commit";
-
-function getRepoRoot() {
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  return path.resolve(here, "..");
-}
-
-function runGitCommand(args, options = {}) {
-  return spawnSync("git", args, {
-    cwd: options.cwd,
-    encoding: "utf-8",
-    stdio: options.stdio ?? "pipe",
-  });
-}
-
-function ensureExecutable(targetPath) {
-  if (process.platform === "win32") return;
-  if (!fs.existsSync(targetPath)) return;
-  try {
-    const mode = fs.statSync(targetPath).mode & 0o777;
-    if (mode & 0o100) return;
-    fs.chmodSync(targetPath, 0o755);
-  } catch (err) {
-    console.warn(`[setup-git-hooks] chmod failed: ${err}`);
-  }
-}
-
-function isGitAvailable({ repoRoot = getRepoRoot(), runGit = runGitCommand } = {}) {
-  const result = runGit(["--version"], { cwd: repoRoot, stdio: "ignore" });
-  return result.status === 0;
-}
-
-function isGitRepo({ repoRoot = getRepoRoot(), runGit = runGitCommand } = {}) {
-  const result = runGit(["rev-parse", "--is-inside-work-tree"], {
-    cwd: repoRoot,
-    stdio: "pipe",
-  });
-  if (result.status !== 0) return false;
-  return String(result.stdout ?? "").trim() === "true";
-}
-
-function setHooksPath({
-  repoRoot = getRepoRoot(),
-  hooksPath = DEFAULT_HOOKS_PATH,
-  runGit = runGitCommand,
-} = {}) {
-  const result = runGit(["config", "core.hooksPath", hooksPath], {
-    cwd: repoRoot,
-    stdio: "ignore",
-  });
-  return result.status === 0;
-}
-
-function setupGitHooks({
-  repoRoot = getRepoRoot(),
-  hooksPath = DEFAULT_HOOKS_PATH,
-  runGit = runGitCommand,
-} = {}) {
-  if (!isGitAvailable({ repoRoot, runGit })) {
-    return { ok: false, reason: "git-missing" };
-  }
-
-  if (!isGitRepo({ repoRoot, runGit })) {
-    return { ok: false, reason: "not-repo" };
-  }
-
-  if (!setHooksPath({ repoRoot, hooksPath, runGit })) {
-    return { ok: false, reason: "config-failed" };
-  }
-
-  ensureExecutable(path.join(repoRoot, hooksPath, PRE_COMMIT_HOOK));
-
-  return { ok: true };
-}
-
-export {
-  DEFAULT_HOOKS_PATH,
-  PRE_COMMIT_HOOK,
-  ensureExecutable,
-  getRepoRoot,
-  isGitAvailable,
-  isGitRepo,
-  runGitCommand,
-  setHooksPath,
-  setupGitHooks,
-};
-
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  setupGitHooks();
-}

package/skills/webgpu-threejs-tsl/REFERENCE.md

@@ -1,283 +0,0 @@
-# TSL Quick Reference
-
-## Imports
-
-```javascript
-// WebGPU Three.js
-import * as THREE from 'three/webgpu';
-
-// Core TSL
-import {
-  float, int, uint, bool,
-  vec2, vec3, vec4, color,
-  mat2, mat3, mat4,
-  uniform, texture, uv,
-  Fn, If, Loop, Break, Continue,
-  time, deltaTime
-} from 'three/tsl';
-```
-
-## Types
-
-| TSL | WGSL | Example |
-|-----|------|---------|
-| `float(1.0)` | `f32` | Scalar float |
-| `int(1)` | `i32` | Signed integer |
-| `uint(1)` | `u32` | Unsigned integer |
-| `bool(true)` | `bool` | Boolean |
-| `vec2(x, y)` | `vec2<f32>` | 2D vector |
-| `vec3(x, y, z)` | `vec3<f32>` | 3D vector |
-| `vec4(x, y, z, w)` | `vec4<f32>` | 4D vector |
-| `color(0xff0000)` | `vec3<f32>` | RGB color |
-| `uniform(value)` | uniform | Dynamic value |
-
-## Operators
-
-| Operation | TSL | GLSL Equivalent |
-|-----------|-----|-----------------|
-| Add | `a.add(b)` | `a + b` |
-| Subtract | `a.sub(b)` | `a - b` |
-| Multiply | `a.mul(b)` | `a * b` |
-| Divide | `a.div(b)` | `a / b` |
-| Modulo | `a.mod(b)` | `mod(a, b)` |
-| Negate | `a.negate()` | `-a` |
-| Less Than | `a.lessThan(b)` | `a < b` |
-| Greater Than | `a.greaterThan(b)` | `a > b` |
-| Equal | `a.equal(b)` | `a == b` |
-| And | `a.and(b)` | `a && b` |
-| Or | `a.or(b)` | `a \|\| b` |
-| Assign | `a.assign(b)` | `a = b` |
-| Add Assign | `a.addAssign(b)` | `a += b` |
-
-## Swizzling
-
-```javascript
-const v = vec3(1, 2, 3);
-v.x        // 1
-v.xy       // vec2(1, 2)
-v.zyx      // vec3(3, 2, 1)
-v.rgb      // same as xyz
-```
-
-## Math Functions
-
-| Function | Description |
-|----------|-------------|
-| `abs(x)` | Absolute value |
-| `sign(x)` | Sign (-1, 0, 1) |
-| `floor(x)` | Round down |
-| `ceil(x)` | Round up |
-| `fract(x)` | Fractional part |
-| `min(a, b)` | Minimum |
-| `max(a, b)` | Maximum |
-| `clamp(x, lo, hi)` | Clamp to range |
-| `mix(a, b, t)` | Linear interpolation |
-| `step(edge, x)` | Step function |
-| `smoothstep(a, b, x)` | Smooth step |
-| `sin(x)`, `cos(x)` | Trigonometry |
-| `pow(x, y)` | Power |
-| `sqrt(x)` | Square root |
-| `length(v)` | Vector length |
-| `distance(a, b)` | Distance |
-| `dot(a, b)` | Dot product |
-| `cross(a, b)` | Cross product |
-| `normalize(v)` | Unit vector |
-| `reflect(i, n)` | Reflection |
-
-## Geometry Nodes
-
-| Node | Description |
-|------|-------------|
-| `positionLocal` | Model space position |
-| `positionWorld` | World space position |
-| `positionView` | Camera space position |
-| `normalLocal` | Model space normal |
-| `normalWorld` | World space normal |
-| `normalView` | Camera space normal |
-| `uv()` | UV coordinates |
-| `uv(1)` | Secondary UVs |
-| `tangentLocal` | Tangent vector |
-| `vertexColor()` | Vertex colors |
-
-## Camera Nodes
-
-| Node | Description |
-|------|-------------|
-| `cameraPosition` | Camera world position |
-| `cameraNear` | Near plane |
-| `cameraFar` | Far plane |
-| `cameraViewMatrix` | View matrix |
-| `cameraProjectionMatrix` | Projection matrix |
-| `screenUV` | Screen UV (0-1) |
-| `screenSize` | Screen dimensions |
-
-## Time
-
-| Node | Description |
-|------|-------------|
-| `time` | Seconds since start |
-| `deltaTime` | Frame delta |
-| `oscSine(t)` | Sine wave (0-1) |
-| `oscSquare(t)` | Square wave |
-| `oscTriangle(t)` | Triangle wave |
-| `oscSawtooth(t)` | Sawtooth wave |
-
-## Material Properties
-
-```javascript
-const mat = new THREE.MeshStandardNodeMaterial();
-
-// Basic
-mat.colorNode = color(0xff0000);
-mat.opacityNode = float(0.8);
-mat.alphaTestNode = float(0.5);
-
-// PBR
-mat.roughnessNode = float(0.5);
-mat.metalnessNode = float(0.0);
-mat.emissiveNode = color(0x000000);
-mat.normalNode = normalMap(tex);
-
-// Physical (MeshPhysicalNodeMaterial)
-mat.clearcoatNode = float(1.0);
-mat.transmissionNode = float(0.9);
-mat.iridescenceNode = float(1.0);
-mat.sheenNode = float(1.0);
-
-// Vertex
-mat.positionNode = displaced;
-```
-
-## Control Flow
-
-```javascript
-// If-Else
-If(condition, () => {
-  // true
-}).ElseIf(other, () => {
-  // other true
-}).Else(() => {
-  // false
-});
-
-// Select (ternary)
-const result = select(condition, trueVal, falseVal);
-
-// Loop
-Loop(10, ({ i }) => {
-  // i = 0 to 9
-});
-
-// Loop control
-Break();
-Continue();
-Discard();  // Fragment only
-```
-
-## Custom Functions
-
-```javascript
-// Basic function
-const myFn = Fn(([a, b]) => {
-  return a.add(b);
-});
-
-// With defaults
-const myFn = Fn(([a = 1.0, b = 2.0]) => {
-  return a.add(b);
-});
-
-// Usage
-myFn(x, y);
-myFn();  // uses defaults
-```
-
-## Compute Shaders
-
-```javascript
-// Storage buffers
-const positions = instancedArray(count, 'vec3');
-const values = instancedArray(count, 'float');
-
-// Compute shader
-const compute = Fn(() => {
-  const pos = positions.element(instanceIndex);
-  pos.addAssign(vec3(0.01, 0, 0));
-})().compute(count);
-
-// Execute
-await renderer.computeAsync(compute);  // Once
-renderer.compute(compute);              // Each frame
-```
-
-## Post-Processing
-
-```javascript
-import { pass } from 'three/tsl';
-import { bloom } from 'three/addons/tsl/display/BloomNode.js';
-
-// Setup
-const postProcessing = new THREE.PostProcessing(renderer);
-const scenePass = pass(scene, camera);
-const color = scenePass.getTextureNode('output');
-
-// Apply effects
-const bloomPass = bloom(color);
-postProcessing.outputNode = color.add(bloomPass);
-
-// Render
-postProcessing.render();
-```
-
-## Common Patterns
-
-### Fresnel
-
-```javascript
-const viewDir = cameraPosition.sub(positionWorld).normalize();
-const fresnel = float(1).sub(normalWorld.dot(viewDir).saturate()).pow(3);
-```
-
-### Animated UV
-
-```javascript
-const animUV = uv().add(vec2(time.mul(0.1), 0));
-```
-
-### Noise Hash
-
-```javascript
-const noise = fract(position.dot(vec3(12.9898, 78.233, 45.543)).sin().mul(43758.5453));
-```
-
-### Dissolve
-
-```javascript
-const noise = hash(positionLocal.mul(50));
-If(noise.lessThan(threshold), () => Discard());
-```
-
-### Color Gradient
-
-```javascript
-const gradient = mix(colorA, colorB, positionLocal.y.mul(0.5).add(0.5));
-```
-
-## Node Materials
-
-| Material | Use Case |
-|----------|----------|
-| `MeshBasicNodeMaterial` | Unlit |
-| `MeshStandardNodeMaterial` | PBR |
-| `MeshPhysicalNodeMaterial` | Advanced PBR |
-| `MeshPhongNodeMaterial` | Phong shading |
-| `MeshToonNodeMaterial` | Cel shading |
-| `PointsNodeMaterial` | Point clouds |
-| `LineBasicNodeMaterial` | Lines |
-| `SpriteNodeMaterial` | Sprites |
-
-## Resources
-
-- [TSL Wiki](https://github.com/mrdoob/three.js/wiki/Three.js-Shading-Language)
-- [WebGPU Examples](https://github.com/mrdoob/three.js/tree/master/examples)
-- [Three.js Docs](https://threejs.org/docs/)