gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/tests/worktree-post-create-hook.test.ts

@@ -1,165 +0,0 @@
-/**
- * worktree-post-create-hook.test.ts — Tests for #597 worktree post-create hook.
- *
- * Verifies that runWorktreePostCreateHook correctly executes user scripts
- * with SOURCE_DIR and WORKTREE_DIR environment variables.
- *
- * Uses Node.js scripts instead of bash for Windows compatibility.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, existsSync, writeFileSync, readFileSync, chmodSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { runWorktreePostCreateHook } from "../auto-worktree.ts";
-
-function makeTmpDir(): string {
-  return mkdtempSync(join(tmpdir(), "gsd-wt-hook-test-"));
-}
-
-const isWin = process.platform === "win32";
-
-/** Return the platform-appropriate hook file path (adds .bat on Windows). */
-function hookPath(base: string): string {
-  return isWin ? `${base}.bat` : base;
-}
-
-/** Create a cross-platform Node.js hook script. */
-function writeNodeHookScript(filePath: string, code: string): void {
-  if (isWin) {
-    // Write the JS code to a companion .js file and have the .bat invoke it.
-    // node -e with multi-line code breaks on Windows because cmd.exe splits on newlines.
-    const jsPath = filePath.replace(/\.bat$/, ".js");
-    writeFileSync(jsPath, code);
-    writeFileSync(filePath, `@echo off\nnode "%~dp0${jsPath.split("\\").pop()}" %*\n`);
-  } else {
-    writeFileSync(filePath, `#!/usr/bin/env node\n${code}\n`);
-    chmodSync(filePath, 0o755);
-  }
-}
-
-// ─── runWorktreePostCreateHook ──────────────────────────────────────────────
-
-test("returns null when no hook path is provided", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const result = runWorktreePostCreateHook(src, wt, undefined);
-    assert.equal(result, null);
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("returns error when hook script does not exist", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const result = runWorktreePostCreateHook(src, wt, ".gsd/hooks/nonexistent");
-    assert.ok(result !== null, "should return error string");
-    assert.ok(result!.includes("not found"), "error should mention 'not found'");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("executes hook script with correct SOURCE_DIR and WORKTREE_DIR env vars", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const hooksDir = join(src, ".gsd", "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-    const hookFile = hookPath(join(hooksDir, "post-create"));
-    const code = [
-      `const fs = require("fs");`,
-      `const path = require("path");`,
-      `const out = path.join(process.env.WORKTREE_DIR, "hook-output.txt");`,
-      `fs.writeFileSync(out, "SOURCE=" + process.env.SOURCE_DIR + "\\n" + "WORKTREE=" + process.env.WORKTREE_DIR + "\\n");`,
-    ].join("\n");
-    writeNodeHookScript(hookFile, code);
-
-    const result = runWorktreePostCreateHook(src, wt, hookPath(".gsd/hooks/post-create"));
-    assert.equal(result, null, "should succeed");
-
-    const outputFile = join(wt, "hook-output.txt");
-    assert.ok(existsSync(outputFile), "hook should have created output file");
-
-    const output = readFileSync(outputFile, "utf-8");
-    assert.ok(output.includes(`SOURCE=${src}`), "SOURCE_DIR should match source dir");
-    assert.ok(output.includes(`WORKTREE=${wt}`), "WORKTREE_DIR should match worktree dir");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("returns error message when hook script fails", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const hooksDir = join(src, ".gsd", "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-    const hookFile = hookPath(join(hooksDir, "failing-hook"));
-    writeNodeHookScript(hookFile, `process.exit(1);`);
-
-    const result = runWorktreePostCreateHook(src, wt, hookPath(".gsd/hooks/failing-hook"));
-    assert.ok(result !== null, "should return error string");
-    assert.ok(result!.includes("hook failed"), "error should mention 'hook failed'");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("supports absolute hook paths", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const hookFile = hookPath(join(src, "absolute-hook"));
-    const code = [
-      `const fs = require("fs");`,
-      `const path = require("path");`,
-      `fs.writeFileSync(path.join(process.env.WORKTREE_DIR, "absolute-hook-ran"), "");`,
-    ].join("\n");
-    writeNodeHookScript(hookFile, code);
-
-    const result = runWorktreePostCreateHook(src, wt, hookFile);
-    assert.equal(result, null, "absolute path hook should succeed");
-    assert.ok(existsSync(join(wt, "absolute-hook-ran")), "hook should have run");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("hook can copy files from source to worktree", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    writeFileSync(join(src, ".env"), "DB_HOST=localhost\nAPI_KEY=secret123\n");
-
-    const hookFile = hookPath(join(src, "setup-hook"));
-    const code = [
-      `const fs = require("fs");`,
-      `const path = require("path");`,
-      `const envSrc = path.join(process.env.SOURCE_DIR, ".env");`,
-      `const envDst = path.join(process.env.WORKTREE_DIR, ".env");`,
-      `fs.copyFileSync(envSrc, envDst);`,
-    ].join("\n");
-    writeNodeHookScript(hookFile, code);
-
-    const result = runWorktreePostCreateHook(src, wt, hookFile);
-    assert.equal(result, null, "hook should succeed");
-
-    assert.ok(existsSync(join(wt, ".env")), ".env should be copied to worktree");
-    const envContent = readFileSync(join(wt, ".env"), "utf-8");
-    assert.ok(envContent.includes("API_KEY=secret123"), ".env content should match");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});

package/dist/resources/extensions/gsd/tests/worktree.test.ts

@@ -1,171 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import {
-  autoCommitCurrentBranch,
-  captureIntegrationBranch,
-  detectWorktreeName,
-  getCurrentBranch,
-  getMainBranch,
-  getSliceBranchName,
-  parseSliceBranch,
-  setActiveMilestoneId,
-  SLICE_BRANCH_RE,
-} from "../worktree.ts";
-import { readIntegrationBranch } from "../git-service.ts";
-import { _resetHasChangesCache } from "../native-git-bridge.ts";
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-function run(command: string, cwd: string): string {
-  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-const base = mkdtempSync(join(tmpdir(), "gsd-branch-test-"));
-run("git init -b main", base);
-run('git config user.name "Pi Test"', base);
-run('git config user.email "pi@example.com"', base);
-mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
-writeFileSync(join(base, "README.md"), "hello\n", "utf-8");
-writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), `# M001: Demo\n\n## Slices\n- [ ] **S01: Slice One** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`, "utf-8");
-writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"), `# S01: Slice One\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  do it\n`, "utf-8");
-run("git add .", base);
-run('git commit -m "chore: init"', base);
-
-async function main(): Promise<void> {
-
-  console.log("\n=== autoCommitCurrentBranch ===");
-  // Clean — should return null
-  const cleanResult = autoCommitCurrentBranch(base, "execute-task", "M001/S01/T01");
-  assertEq(cleanResult, null, "returns null for clean repo");
-
-  // Make dirty — reset the nativeHasChanges cache so the fresh dirt is detected
-  _resetHasChangesCache();
-  writeFileSync(join(base, "dirty.txt"), "uncommitted\n", "utf-8");
-  const dirtyResult = autoCommitCurrentBranch(base, "execute-task", "M001/S01/T01");
-  assertTrue(dirtyResult !== null, "returns commit message for dirty repo");
-  assertTrue(dirtyResult!.includes("M001/S01/T01"), "commit message includes unit id");
-  assertEq(run("git status --short", base), "", "repo is clean after auto-commit");
-
-  console.log("\n=== getSliceBranchName ===");
-  assertEq(getSliceBranchName("M001", "S01"), "gsd/M001/S01", "branch name format correct");
-  assertEq(getSliceBranchName("M001", "S01", null), "gsd/M001/S01", "null worktree = plain branch");
-  assertEq(getSliceBranchName("M001", "S01", "my-wt"), "gsd/my-wt/M001/S01", "worktree-namespaced branch");
-
-  console.log("\n=== parseSliceBranch ===");
-  const plain = parseSliceBranch("gsd/M001/S01");
-  assertTrue(plain !== null, "parses plain branch");
-  assertEq(plain!.worktreeName, null, "plain branch has no worktree name");
-  assertEq(plain!.milestoneId, "M001", "plain branch milestone");
-  assertEq(plain!.sliceId, "S01", "plain branch slice");
-
-  const namespaced = parseSliceBranch("gsd/feature-auth/M001/S01");
-  assertTrue(namespaced !== null, "parses worktree-namespaced branch");
-  assertEq(namespaced!.worktreeName, "feature-auth", "worktree name extracted");
-  assertEq(namespaced!.milestoneId, "M001", "namespaced branch milestone");
-  assertEq(namespaced!.sliceId, "S01", "namespaced branch slice");
-
-  const invalid = parseSliceBranch("main");
-  assertEq(invalid, null, "non-slice branch returns null");
-
-  const worktreeBranch = parseSliceBranch("worktree/foo");
-  assertEq(worktreeBranch, null, "worktree/ prefix is not a slice branch");
-
-  console.log("\n=== SLICE_BRANCH_RE ===");
-  assertTrue(SLICE_BRANCH_RE.test("gsd/M001/S01"), "regex matches plain branch");
-  assertTrue(SLICE_BRANCH_RE.test("gsd/my-wt/M001/S01"), "regex matches worktree branch");
-  assertTrue(!SLICE_BRANCH_RE.test("main"), "regex rejects main");
-  assertTrue(!SLICE_BRANCH_RE.test("gsd/"), "regex rejects bare gsd/");
-  assertTrue(!SLICE_BRANCH_RE.test("worktree/foo"), "regex rejects worktree/foo");
-
-  console.log("\n=== detectWorktreeName ===");
-  assertEq(detectWorktreeName("/projects/myapp"), null, "no worktree in plain path");
-  assertEq(detectWorktreeName("/projects/myapp/.gsd/worktrees/feature-auth"), "feature-auth", "detects worktree name");
-  assertEq(detectWorktreeName("/projects/myapp/.gsd/worktrees/my-wt/subdir"), "my-wt", "detects worktree with subdir");
-
-  // ═══════════════════════════════════════════════════════════════════════
-  // Integration branch — facade-level tests
-  // ═══════════════════════════════════════════════════════════════════════
-
-  // ── captureIntegrationBranch on a feature branch ──────────────────────
-
-  console.log("\n=== captureIntegrationBranch: records current branch ===");
-
-  {
-    const repo = mkdtempSync(join(tmpdir(), "gsd-integ-facade-"));
-    run("git init -b main", repo);
-    run("git config user.name 'Pi Test'", repo);
-    run("git config user.email 'pi@example.com'", repo);
-    writeFileSync(join(repo, "README.md"), "init\n");
-    run("git add -A && git commit -m init", repo);
-
-    run("git checkout -b f-123-thing", repo);
-    assertEq(getCurrentBranch(repo), "f-123-thing", "on feature branch");
-
-    captureIntegrationBranch(repo, "M001");
-    assertEq(readIntegrationBranch(repo, "M001"), "f-123-thing",
-      "captureIntegrationBranch records the current branch");
-
-    // .gsd/ metadata is written to disk only (not committed) since commit_docs removal
-    rmSync(repo, { recursive: true, force: true });
-  }
-
-  // ── captureIntegrationBranch skips slice branches ─────────────────────
-
-  console.log("\n=== captureIntegrationBranch: skips slice branches ===");
-
-  {
-    const repo = mkdtempSync(join(tmpdir(), "gsd-integ-skip-"));
-    run("git init -b main", repo);
-    run("git config user.name 'Pi Test'", repo);
-    run("git config user.email 'pi@example.com'", repo);
-    writeFileSync(join(repo, "README.md"), "init\n");
-    run("git add -A && git commit -m init", repo);
-
-    run("git checkout -b gsd/M001/S01", repo);
-    captureIntegrationBranch(repo, "M001");
-
-    assertEq(readIntegrationBranch(repo, "M001"), null,
-      "capture from slice branch is a no-op");
-
-    rmSync(repo, { recursive: true, force: true });
-  }
-
-  // ── setActiveMilestoneId makes getMainBranch return integration branch ─
-
-  console.log("\n=== setActiveMilestoneId + getMainBranch ===");
-
-  {
-    const repo = mkdtempSync(join(tmpdir(), "gsd-integ-main-"));
-    run("git init -b main", repo);
-    run("git config user.name 'Pi Test'", repo);
-    run("git config user.email 'pi@example.com'", repo);
-    writeFileSync(join(repo, "README.md"), "init\n");
-    run("git add -A && git commit -m init", repo);
-
-    run("git checkout -b my-feature", repo);
-    captureIntegrationBranch(repo, "M001");
-
-    // Without milestone set, getMainBranch returns "main"
-    setActiveMilestoneId(repo, null);
-    assertEq(getMainBranch(repo), "main",
-      "getMainBranch returns main without milestone set");
-
-    // With milestone set, getMainBranch returns feature branch
-    setActiveMilestoneId(repo, "M001");
-    assertEq(getMainBranch(repo), "my-feature",
-      "getMainBranch returns integration branch with milestone set");
-
-    rmSync(repo, { recursive: true, force: true });
-  }
-
-  rmSync(base, { recursive: true, force: true });
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});

package/dist/resources/extensions/gsd/tests/write-gate.test.ts

@@ -1,211 +0,0 @@
-/**
- * Unit tests for the CONTEXT.md write-gate.
- *
- * Exercises shouldBlockContextWrite() — a pure function that implements:
- *   (a) toolName !== "write" → pass
- *   (b) milestoneId null AND no queue phase → pass (not in any flow)
- *   (c) path doesn't match /M\d+-CONTEXT\.md$/ → pass
- *   (d) depthVerified → pass (backward compat for discussion flows)
- *   (e) queuePhaseActive + per-milestone verified → pass
- *   (f) queuePhaseActive + not verified → block
- *   (g) else → block with actionable reason
- *
- * Also exercises per-milestone verification helpers:
- *   markDepthVerified(), isDepthVerifiedFor()
- */
-
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  shouldBlockContextWrite,
-  markDepthVerified,
-  isDepthVerifiedFor,
-  isDepthVerified,
-} from '../index.ts';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Discussion flow tests (backward compatibility)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('write-gate: blocks CONTEXT.md write during discussion without depth verification (absolute path)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '/Users/dev/project/.gsd/milestones/M001/M001-CONTEXT.md',
-    'M001',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should block the write');
-  assert.ok(result.reason, 'should provide a reason');
-});
-
-test('write-gate: blocks CONTEXT.md write during discussion without depth verification (relative path)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M005/M005-CONTEXT.md',
-    'M005',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should block the write');
-  assert.ok(result.reason, 'should provide a reason');
-});
-
-test('write-gate: allows CONTEXT.md write after depth verification (discussion flow)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '/Users/dev/project/.gsd/milestones/M001/M001-CONTEXT.md',
-    'M001',
-    true,
-  );
-  assert.strictEqual(result.block, false, 'should not block after depth verification');
-  assert.strictEqual(result.reason, undefined, 'should have no reason');
-});
-
-test('write-gate: allows CONTEXT.md write outside any flow (milestoneId null, no queue)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M001/M001-CONTEXT.md',
-    null,
-    false,
-    false,
-  );
-  assert.strictEqual(result.block, false, 'should not block outside any flow');
-});
-
-test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
-  const r1 = shouldBlockContextWrite('write', '.gsd/milestones/M001/M001-DISCUSSION.md', 'M001', false);
-  assert.strictEqual(r1.block, false, 'DISCUSSION.md should pass');
-
-  const r2 = shouldBlockContextWrite('write', '.gsd/milestones/M001/slices/S01/S01-PLAN.md', 'M001', false);
-  assert.strictEqual(r2.block, false, 'slice plan should pass');
-
-  const r3 = shouldBlockContextWrite('write', 'src/index.ts', 'M001', false);
-  assert.strictEqual(r3.block, false, 'regular code file should pass');
-});
-
-test('write-gate: regex does not match slice context files (S01-CONTEXT.md)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M001/slices/S01/S01-CONTEXT.md',
-    'M001',
-    false,
-  );
-  assert.strictEqual(result.block, false, 'S01-CONTEXT.md should not be blocked');
-});
-
-test('write-gate: blocked reason contains actionable instructions', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M999/M999-CONTEXT.md',
-    'M999',
-    false,
-  );
-  assert.strictEqual(result.block, true);
-  assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification');
-  assert.ok(result.reason!.includes('ask_user_questions'), 'reason should mention ask_user_questions');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Queue flow tests (NEW — enforces write-gate during /gsd queue)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('write-gate: blocks CONTEXT.md write during queue flow without verification', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    null,  // queue flows have no pendingAutoStart → milestoneId is null
-    false,
-    true,  // but queuePhaseActive is true
-  );
-  assert.strictEqual(result.block, true, 'should block during queue flow without verification');
-  assert.ok(result.reason!.includes('multi-milestone'), 'reason should mention multi-milestone');
-});
-
-test('write-gate: allows CONTEXT.md write during queue flow AFTER per-milestone verification', () => {
-  // Simulate: depth_verification_M010-3ym37m was answered
-  markDepthVerified('M010-3ym37m');
-
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(result.block, false, 'should allow after per-milestone verification');
-});
-
-test('write-gate: blocks DIFFERENT milestone in queue flow when only one is verified', () => {
-  // M010-3ym37m was verified above, but M011-rfmd3q was NOT
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M011-rfmd3q/M011-rfmd3q-CONTEXT.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(result.block, true, 'should block unverified milestone even when another is verified');
-});
-
-test('write-gate: wildcard verification unlocks all milestones in queue flow', () => {
-  markDepthVerified('*');
-
-  const r1 = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M099/M099-CONTEXT.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(r1.block, false, 'wildcard should pass any milestone');
-});
-
-test('write-gate: allows non-CONTEXT.md writes during queue flow regardless', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/QUEUE.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(result.block, false, 'QUEUE.md should pass during queue flow');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Unique milestone ID format tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('write-gate: matches unique milestone ID format (M010-3ym37m)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    'M010-3ym37m',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should match unique milestone ID format');
-});
-
-test('write-gate: matches classic milestone ID format (M001)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M001/M001-CONTEXT.md',
-    'M001',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should match classic milestone ID format');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Per-milestone depth verification helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('isDepthVerifiedFor: returns false for unknown milestone', () => {
-  assert.strictEqual(isDepthVerifiedFor('M999-xxxxxx'), true,
-    'returns true because wildcard * was set in earlier test');
-  // Note: test isolation would require clearing state, but these tests
-  // exercise the module as a singleton (matching production behavior)
-});
-
-test('isDepthVerified: returns true when any milestone verified', () => {
-  // At this point M010-3ym37m and * are verified from earlier tests
-  assert.strictEqual(isDepthVerified(), true);
-});

package/dist/resources/extensions/gsd/token-counter.ts

@@ -1,65 +0,0 @@
-export type TokenProvider = "anthropic" | "openai" | "google" | "mistral" | "bedrock" | "unknown";
-
-const CHARS_PER_TOKEN_BY_PROVIDER: Record<TokenProvider, number> = {
-	anthropic: 3.5,
-	openai: 4.0,
-	google: 4.0,
-	mistral: 3.8,
-	bedrock: 3.5,
-	unknown: 4.0,
-};
-
-interface TokenEncoder {
-	encode(text: string): Uint32Array | number[];
-}
-
-let encoder: TokenEncoder | null = null;
-let encoderFailed = false;
-
-async function getEncoder(): Promise<TokenEncoder | null> {
-	if (encoder) return encoder;
-	if (encoderFailed) return null;
-	try {
-		// @ts-ignore — tiktoken may not have type declarations in extensions tsconfig
-		const tiktoken = await import("tiktoken");
-		encoder = tiktoken.encoding_for_model("gpt-4o") as TokenEncoder;
-		return encoder;
-	} catch {
-		encoderFailed = true;
-		return null;
-	}
-}
-
-export async function countTokens(text: string): Promise<number> {
-	const enc = await getEncoder();
-	if (enc) {
-		const tokens = enc.encode(text);
-		return tokens.length;
-	}
-	return Math.ceil(text.length / 4);
-}
-
-export function countTokensSync(text: string): number {
-	if (encoder) {
-		return encoder.encode(text).length;
-	}
-	return Math.ceil(text.length / 4);
-}
-
-export async function initTokenCounter(): Promise<boolean> {
-	const enc = await getEncoder();
-	return enc !== null;
-}
-
-export function isAccurateCountingAvailable(): boolean {
-	return encoder !== null;
-}
-
-export function getCharsPerToken(provider: TokenProvider): number {
-	return CHARS_PER_TOKEN_BY_PROVIDER[provider] ?? CHARS_PER_TOKEN_BY_PROVIDER.unknown;
-}
-
-export function estimateTokensForProvider(text: string, provider: TokenProvider): number {
-	const ratio = getCharsPerToken(provider);
-	return Math.ceil(text.length / ratio);
-}