@maxiaochao/pi-toolkit 0.9.3 → 0.9.6

package/packages/worktree/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@maxiaochao/pi-worktree",
+  "version": "0.1.0",
+  "description": "Git worktree CLI and Pi skill for isolated coding tasks.",
+  "type": "module",
+  "keywords": ["pi-package", "pi-skill", "git", "worktree"],
+  "files": ["bin", "skills", "scripts", "docs", "README.md", "TESTING.md", "CHANGELOG.md"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chaochaoxiaochao/pi-toolkit.git",
+    "directory": "packages/worktree"
+  },
+  "bin": { "pi-worktree": "bin/pi-worktree" },
+  "pi": { "skills": ["./skills"] },
+  "scripts": {
+    "test": "node --test tests/install.test.mjs && bash tests/run-tests.sh",
+    "postinstall": "node scripts/install.mjs"
+  },
+  "publishConfig": { "access": "public" }
+}

package/packages/worktree/scripts/install.mjs

@@ -0,0 +1,26 @@
+import { chmodSync, copyFileSync, mkdirSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+export function installWorktree({ root = packageRoot, home = homedir() } = {}) {
+  if (platform() === "win32") return [];
+  const installed = [];
+  const binTarget = join(home, ".local", "bin", "pi-worktree");
+  mkdirSync(dirname(binTarget), { recursive: true });
+  copyFileSync(join(root, "bin", "pi-worktree"), binTarget);
+  chmodSync(binTarget, 0o755);
+  installed.push(binTarget);
+
+  const completionTarget = join(home, ".local", "share", "bash-completion", "completions", "pi-worktree");
+  mkdirSync(dirname(completionTarget), { recursive: true });
+  copyFileSync(join(root, "bin", "pi-worktree-completion.bash"), completionTarget);
+  installed.push(completionTarget);
+  return installed;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  for (const path of installWorktree()) console.log(`[pi-worktree] installed -> ${path}`);
+}

package/packages/worktree/tests/install.test.mjs

@@ -0,0 +1,25 @@
+import assert from "node:assert/strict";
+import { access, mkdtemp, readFile, rm } from "node:fs/promises";
+import { constants } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+import { installWorktree } from "../scripts/install.mjs";
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+test("installs the CLI and completion into an isolated home", async () => {
+  const home = await mkdtemp(join(tmpdir(), "pi-worktree-install-"));
+  try {
+    const installed = installWorktree({ root: packageRoot, home });
+    const cli = join(home, ".local", "bin", "pi-worktree");
+    const completion = join(home, ".local", "share", "bash-completion", "completions", "pi-worktree");
+    assert.deepEqual(installed, [cli, completion]);
+    await access(cli, constants.X_OK);
+    assert.match(await readFile(cli, "utf8"), /git worktree/);
+    assert.match(await readFile(completion, "utf8"), /complete -F _pi_worktree/);
+  } finally {
+    await rm(home, { recursive: true, force: true });
+  }
+});

package/packages/worktree/tests/run-tests.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PACKAGE_DIR=$(cd "$(dirname "$0")/.." && pwd)
+ROOT=$(mktemp -d)
+trap 'rm -rf "$ROOT"' EXIT
+
+mkdir -p "$ROOT/bin"
+cat > "$ROOT/bin/pi" <<'EOF'
+#!/usr/bin/env bash
+printf '%s\n' "$PWD" > "${PI_WORKTREE_TEST_OUTPUT}.cwd"
+printf '%s\n' "$@" > "${PI_WORKTREE_TEST_OUTPUT}.args"
+EOF
+chmod +x "$ROOT/bin/pi"
+
+mkdir "$ROOT/repo"
+cd "$ROOT/repo"
+git init -q -b main
+git config user.email test@example.com
+git config user.name Test
+printf '.worktrees/\n' > .gitignore
+printf 'base\n' > tracked.txt
+git add .gitignore tracked.txt
+git commit -qm initial
+
+export PATH="$ROOT/bin:$PATH"
+export PI_WORKTREE_TEST_OUTPUT="$ROOT/pi"
+bash "$PACKAGE_DIR/bin/pi-worktree" start feature --model fake/model
+
+test -d .worktrees/feature
+test "$(git -C .worktrees/feature branch --show-current)" = feature
+test "$(cat "$ROOT/pi.cwd")" = "$ROOT/repo/.worktrees/feature"
+grep -qx -- '--model' "$ROOT/pi.args"
+grep -qx -- 'fake/model' "$ROOT/pi.args"
+
+bash "$PACKAGE_DIR/bin/pi-worktree" list > "$ROOT/list.txt"
+grep -q 'main checkout' "$ROOT/list.txt"
+grep -q 'feature' "$ROOT/list.txt"
+
+bash "$PACKAGE_DIR/bin/pi-worktree" info feature > "$ROOT/info.txt"
+grep -q 'status:   clean' "$ROOT/info.txt"
+grep -q 'branch:   feature' "$ROOT/info.txt"
+grep -q 'based on:' "$ROOT/info.txt"
+
+bash "$PACKAGE_DIR/bin/pi-worktree" --help | grep -q 'pi-worktree start'
+printf 'PASS worktree CLI integration cases\n'

package/scripts/install-agents.mjs

@@ -1,9 +1,10 @@
 // postinstall hook: sync the bundled global AGENTS.md and seed the default theme
 // without overriding a theme the user has already selected.
-import { readFileSync, writeFileSync, mkdirSync, existsSync, copyFileSync, chmodSync } from "node:fs";
-import { homedir, platform } from "node:os";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { installWorktree } from "../packages/worktree/scripts/install.mjs";
 
 const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -44,21 +45,10 @@ if (!existsSync(settingsTarget)) {
   }
 }
 
-// Install the pi-worktree CLI + bash completion on Unix-like systems.
-// Copy (not symlink) so the running command does not depend on the repo/node_modules layout.
-if (platform() !== "win32") {
-  try {
-    const binTarget = join(homedir(), ".local", "bin", "pi-worktree");
-    mkdirSync(dirname(binTarget), { recursive: true });
-    copyFileSync(join(packageRoot, "bin", "pi-worktree"), binTarget);
-    chmodSync(binTarget, 0o755);
-    console.log("[pi-toolkit] pi-worktree installed ->", binTarget);
-
-    const compTarget = join(homedir(), ".local", "share", "bash-completion", "completions", "pi-worktree");
-    mkdirSync(dirname(compTarget), { recursive: true });
-    copyFileSync(join(packageRoot, "bin", "pi-worktree-completion.bash"), compTarget);
-    console.log("[pi-toolkit] pi-worktree bash completion installed ->", compTarget);
-  } catch (error) {
-    console.warn("[pi-toolkit] could not install pi-worktree CLI:", error instanceof Error ? error.message : String(error));
+try {
+  for (const path of installWorktree({ root: join(packageRoot, "packages", "worktree") })) {
+    console.log("[pi-toolkit] pi-worktree installed ->", path);
   }
+} catch (error) {
+  console.warn("[pi-toolkit] could not install pi-worktree CLI:", error instanceof Error ? error.message : String(error));
 }

package/extensions/codex-edit/README.md

@@ -1,53 +0,0 @@
-# Codex Edit (apply_patch)
-
-A Pi extension bundled with `@maxiaochao/pi-toolkit` that exposes Codex-style `apply_patch` for GPT/Codex models and keeps Pi's native `edit` tool for other models.
-
-## Install
-
-Bundled with the toolkit; install or update the root package and the extension comes along:
-
-```bash
-pi install npm:@maxiaochao/pi-toolkit
-pi update npm:@maxiaochao/pi-toolkit
-```
-
-The extension registers `apply_patch` and selects the editing tool from the resolved model configuration:
-
-- Allowlisted GPT/Codex model: `apply_patch`
-- Other models: Pi's native `edit`
-
-The default allowlist enables all `gpt-5.6-*` models regardless of provider. Other model families can be added after separate validation by editing `config.json`.
-
-The extension does not add a permanent AGENTS rule telling models not to use `apply_patch`. Only the selected editor tool is active, so the model receives one editing protocol.
-
-## What `apply_patch` does
-
-The tool accepts raw Codex patch text between `*** Begin Patch` and `*** End Patch`. It supports:
-
-- `Add File`
-- `Delete File`
-- `Update File`
-- `Move to`
-- multiple update hunks with `@@` context
-- EOF-oriented insertions
-
-Before writing, it parses the complete patch, resolves paths, rejects workspace escapes and unsafe symlink/parent paths, reads all source files, and computes every update in memory. Only after preflight succeeds does it mutate files. It returns per-file diff details and reports committed paths if a later filesystem operation fails.
-
-## Configuration
-
-The extension defaults to a model-ID allowlist in `config.json`: `"gpt-5.6-*"`. Provider does not affect routing. Each entry is a `*` glob, so this matches every `gpt-5.6-` variant. The route additionally requires:
-
-```text
-model.api = openai-responses or openai-codex-responses
-```
-
-Grammar support is not part of the route. When a provider does not emit Lark grammar tools, Pi falls back to a normal function tool, so `apply_patch` still runs there — only the grammar-enforced output shape is lost.
-
-Edit `extensions/codex-edit/config.json` inside the installed `@maxiaochao/pi-toolkit` package only if you need to change the default allowlist. The implementation keeps both tools registered for session replay and changes only the active tool set on `session_start` and `model_select`.
-
-## Documentation
-
-- `summary.md`: benchmark summary and decision record.
-- `codex-edit-explainer.html`: self-contained interactive architecture and configuration explainer.
-
-The benchmark found equal final correctness in the fair 20-case comparison, with first editor-call success improving from 85% to 95%. Overall tool-call count and cache-inclusive token use were effectively unchanged, so the route stays limited to the GPT/Codex allowlist rather than replacing `edit` universally.

package/extensions/codex-edit/tests/package.test.mjs

@@ -1,38 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import test from "node:test";
-import { modelIsAllowed } from "../model-routing.ts";
-
-const extensionDir = dirname(dirname(new URL(import.meta.url).pathname));
-
-test("config is next to the extension entry file", async () => {
-  const source = await readFile(join(extensionDir, "index.ts"), "utf8");
-  assert.match(source, /new URL\("\.\/config\.json", import\.meta\.url\)/);
-  assert.match(source, /model-routing\.ts/);
-  const config = JSON.parse(await readFile(join(extensionDir, "config.json"), "utf8"));
-  assert.equal(config.enabled, true);
-  assert.deepEqual(config.models, ["gpt-5.6-*"]);
-});
-
-test("matches allowed model IDs with globs independently of provider and grammar support", () => {
-  const settings = { enabled: true, models: ["gpt-5.6-*"] };
-  const baseModel = {
-    id: "gpt-5.6-terra",
-    api: "openai-codex-responses",
-    compat: { supportsOpenAIGrammarTools: true },
-  };
-  assert.equal(modelIsAllowed({ ...baseModel, provider: "openai-codex" }, settings), true);
-  assert.equal(modelIsAllowed({ ...baseModel, provider: "another-provider" }, settings), true);
-  assert.equal(modelIsAllowed({ ...baseModel, compat: { supportsOpenAIGrammarTools: false } }, settings), true);
-  assert.equal(
-    modelIsAllowed(
-      { ...baseModel, api: "openai-responses", compat: { sessionAffinityFormat: "openai-nosession" } },
-      settings,
-    ),
-    true,
-  );
-  assert.equal(modelIsAllowed({ ...baseModel, api: "openai-completions" }, settings), false);
-  assert.equal(modelIsAllowed({ ...baseModel, id: "gpt-5.5" }, settings), false);
-  assert.equal(modelIsAllowed(baseModel, { enabled: false, models: ["gpt-5.6-*"] }), false);
-});

package/extensions/codex-edit/tests/parser.test.mjs

@@ -1,89 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-import { applyUpdate, parsePatch, resolveWorkspacePath } from "../parser.ts";
-
-test("parses add, delete, update, and move operations", () => {
-  const operations = parsePatch(`*** Begin Patch
-*** Add File: added.txt
-+hello
-*** Delete File: removed.txt
-*** Update File: old.txt
-*** Move to: new.txt
-@@
--old
-+new
-*** End Patch`);
-  assert.deepEqual(operations.map((operation) => operation.action), ["add", "delete", "update"]);
-  assert.equal(operations[0].content, "hello\n");
-  assert.equal(operations[2].moveTo, "new.txt");
-  assert.deepEqual(operations[2].chunks[0].oldLines, ["old"]);
-  assert.deepEqual(operations[2].chunks[0].newLines, ["new"]);
-});
-
-test("rejects malformed patches and duplicate targets", () => {
-  assert.throws(() => parsePatch("bad"), /first line/);
-  assert.throws(() => parsePatch(`*** Begin Patch
-*** Add File: same.txt
-+x
-*** Add File: same.txt
-+y
-*** End Patch`), /same path/);
-});
-
-test("applies multiple chunks using context and preserves BOM and CRLF", () => {
-  const before = "\ufefffunction run() {\r\n  const value = 1;\r\n  return value;\r\n}\r\n";
-  const operations = parsePatch(`*** Begin Patch
-*** Update File: src/run.js
-@@ function run() {
--  const value = 1;
-+  const value = 2;
-@@
--  return value;
-+  return value + 1;
-*** End Patch`);
-  const after = applyUpdate(before, operations[0].chunks, "src/run.js");
-  assert.equal(after, "\ufefffunction run() {\r\n  const value = 2;\r\n  return value + 1;\r\n}\r\n");
-});
-
-test("supports insertion chunks and EOF matching", () => {
-  const operations = parsePatch(`*** Begin Patch
-*** Update File: file.txt
-@@
-+first
-*** End of File
-*** End Patch`);
-  assert.equal(applyUpdate("", operations[0].chunks, "file.txt"), "first\n");
-});
-
-test("rejects ambiguous matches and workspace escapes", () => {
-  const operations = parsePatch(`*** Begin Patch
-*** Update File: file.txt
-@@
--value
-+changed
-*** End Patch`);
-  assert.throws(() => applyUpdate("value\nvalue\n", operations[0].chunks, "file.txt"), /Ambiguous/);
-  assert.equal(resolveWorkspacePath("/tmp/project", "/tmp/project/src/a.js"), "/tmp/project/src/a.js");
-  assert.throws(() => resolveWorkspacePath("/tmp/project", "/tmp/other/a.js"), /escapes/);
-});
-
-test("round-trips a temporary file operation fixture", async () => {
-  const workspace = await mkdtemp(join(tmpdir(), "codex-edit-test-"));
-  try {
-    const path = join(workspace, "file.txt");
-    await writeFile(path, "before\n", "utf8");
-    const operations = parsePatch(`*** Begin Patch
-*** Update File: file.txt
-@@
--before
-+after
-*** End Patch`);
-    await writeFile(path, applyUpdate(await readFile(path, "utf8"), operations[0].chunks, "file.txt"), "utf8");
-    assert.equal(await readFile(path, "utf8"), "after\n");
-  } finally {
-    await rm(workspace, { recursive: true, force: true });
-  }
-});