@mikaelkaron/skills-cherry-pick-filter 0.0.0

package/bin/run.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env -S node --experimental-strip-types
+
+import { execute } from "@oclif/core";
+await execute({ dir: import.meta.url });

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@mikaelkaron/skills-cherry-pick-filter",
+  "version": "0.0.0",
+  "bin": {
+    "mks-cherry-pick-filter": "bin/run.ts"
+  },
+  "files": [
+    "bin",
+    "src",
+    "oclif.manifest.json"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --experimental-strip-types --test 'test/**/*.test.ts'",
+    "test:types": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@oclif/core": "^4"
+  },
+  "devDependencies": {
+    "@oclif/test": "^4.1.18",
+    "@types/node": "^22",
+    "typescript": "^5"
+  },
+  "oclif": {
+    "bin": "mks-cherry-pick-filter",
+    "commands": {
+      "globPatterns": [
+        "**/*.ts"
+      ],
+      "strategy": "pattern",
+      "target": "./src/commands"
+    },
+    "id": "cherry-pick-filter"
+  },
+  "engines": {
+    "node": ">=22.18"
+  },
+  "tessl": {
+    "tile": "mikaelkaron/cherry-pick-filter",
+    "version": "0.1.6"
+  }
+}

package/src/commands/cherry-pick-filter.ts

@@ -0,0 +1,201 @@
+import { Args, Command, Flags } from "@oclif/core";
+import { exec, tryExec } from "../lib/git.ts";
+
+function out(sha: string): void {
+  if (!process.stdout.isTTY) process.stdout.write(sha + "\n");
+}
+
+export default class CherryPickFilter extends Command {
+  static override summary =
+    "Sync a working branch to a clean target branch by cherry-picking commits that don't touch filtered path prefixes.";
+
+  static override description = `Incrementally cherry-picks commits from the current branch onto a target branch, skipping commits where all changed files match filtered path prefixes. Mixed commits (code + filtered files in the same commit) are detected by analyzing all commits first, then reported together, and the operation is halted until the user resolves them.
+
+All human-readable output goes to stderr. stdout emits one picked commit SHA per line — but only when piped (not a TTY).`;
+
+  static override examples = [
+    {
+      description: "Sync to beta, filtering out .planning/ commits",
+      command: "<%= config.bin %> <%= command.id %> beta --filter .planning/",
+    },
+    {
+      description: "Filter multiple path prefixes",
+      command:
+        "<%= config.bin %> <%= command.id %> beta --filter .planning/ --filter .agents/",
+    },
+    {
+      description: "Dry run: analyse without cherry-picking",
+      command:
+        "<%= config.bin %> <%= command.id %> beta --filter .planning/ --dry-run",
+    },
+    {
+      description: "Capture picked SHAs",
+      command:
+        "<%= config.bin %> <%= command.id %> beta --filter .planning/ | xargs git log --oneline",
+    },
+  ];
+
+  static override args = {
+    targetBranch: Args.string({
+      description: "Branch to cherry-pick code commits onto",
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    filter: Flags.string({
+      description:
+        "Path prefix to filter out. Commits where ALL files match are skipped; commits where SOME files match are aborted as mixed.",
+      multiple: true,
+      required: true,
+    }),
+    "dry-run": Flags.boolean({
+      description: "Analyse commits without cherry-picking",
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(CherryPickFilter);
+    const { targetBranch } = args;
+    const filters = flags.filter;
+    const dryRun = flags["dry-run"];
+
+    const currentBranch = exec("git rev-parse --abbrev-ref HEAD");
+
+    if (currentBranch === targetBranch) {
+      this.error(`already on '${targetBranch}'.`, { exit: 1 });
+    }
+
+    const localExists = tryExec(
+      `git show-ref --verify --quiet refs/heads/${targetBranch}`,
+    ).ok;
+
+    if (!localExists) {
+      const remoteResult = tryExec(
+        `git ls-remote --heads origin ${targetBranch}`,
+      );
+      if (remoteResult.ok && remoteResult.output.length > 0) {
+        this.logToStderr(`Checking out '${targetBranch}' from origin...`);
+        const checkoutResult = tryExec(
+          `git checkout --track origin/${targetBranch}`,
+        );
+        if (!checkoutResult.ok) {
+          this.logToStderr(
+            `Error: failed to checkout '${targetBranch}' from origin.`,
+          );
+          this.logToStderr(checkoutResult.output);
+          this.exit(1);
+        }
+        exec(`git checkout ${currentBranch}`);
+      } else {
+        this.error(`branch '${targetBranch}' not found locally or on origin.`, {
+          exit: 1,
+        });
+      }
+    }
+
+    const dryRunLabel = dryRun ? " (dry run)" : "";
+    this.logToStderr(
+      `\nSyncing ${currentBranch} → ${targetBranch}${dryRunLabel}`,
+    );
+    this.logToStderr(`Filter prefixes: ${filters.join(", ")}\n`);
+
+    const pathspecs = filters.map((f) => `:!${f}`).join(" ");
+    const logOutput = tryExec(
+      `git log ${targetBranch}..HEAD --reverse --format="%H %s" -- ${pathspecs}`,
+    );
+
+    if (!logOutput.ok || !logOutput.output) {
+      this.logToStderr("Already up to date.");
+      return;
+    }
+
+    const candidates = logOutput.output
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => ({ sha: line.slice(0, 40), subject: line.slice(41) }));
+
+    if (candidates.length === 0) {
+      this.logToStderr("Already up to date.");
+      return;
+    }
+
+    const mixed: Array<{
+      sha: string;
+      subject: string;
+      filteredFiles: string[];
+      codeFiles: string[];
+    }> = [];
+
+    for (const { sha, subject } of candidates) {
+      const files = exec(`git diff-tree --no-commit-id -r --name-only ${sha}`)
+        .split("\n")
+        .filter(Boolean);
+      const filteredFiles = files.filter((f) =>
+        filters.some((prefix) => f.startsWith(prefix)),
+      );
+      const codeFiles = files.filter(
+        (f) => !filters.some((prefix) => f.startsWith(prefix)),
+      );
+      if (filteredFiles.length > 0 && codeFiles.length > 0) {
+        mixed.push({ sha, subject, filteredFiles, codeFiles });
+      }
+    }
+
+    if (mixed.length > 0) {
+      this.logToStderr("Mixed commits detected — fix these before syncing:\n");
+      for (const { sha, subject, filteredFiles, codeFiles } of mixed) {
+        this.logToStderr(`  ${sha.slice(0, 9)} ${subject}`);
+        this.logToStderr(`    In filter:`);
+        for (const f of filteredFiles) this.logToStderr(`      ${f}`);
+        this.logToStderr(`    Outside filter:`);
+        for (const f of codeFiles) this.logToStderr(`      ${f}`);
+        this.logToStderr("");
+      }
+      this.logToStderr(`Split each commit with:`);
+      this.logToStderr(`  git rebase -i ${mixed[0].sha.slice(0, 9)}^\n`);
+      this.logToStderr(
+        `Then re-run: git cherry-pick-filter ${targetBranch} ${filters.map((f) => `--filter ${f}`).join(" ")}`,
+      );
+      this.exit(1);
+    }
+
+    const verb = dryRun ? "Would pick" : "Ready to pick";
+    this.logToStderr(
+      `${verb} ${candidates.length} commit${candidates.length === 1 ? "" : "s"}:`,
+    );
+    for (const { sha, subject } of candidates) {
+      this.logToStderr(`  ${sha.slice(0, 9)} ${subject}`);
+    }
+    this.logToStderr("");
+
+    if (dryRun) {
+      this.logToStderr("Dry run complete. Run without --dry-run to apply.");
+      return;
+    }
+
+    exec(`git checkout ${targetBranch}`);
+
+    let picked = 0;
+    for (const { sha, subject } of candidates) {
+      const result = tryExec(`git cherry-pick ${sha}`);
+      if (result.ok) {
+        this.logToStderr(`  pick ${sha.slice(0, 9)} ${subject}`);
+        out(sha);
+        picked++;
+      } else {
+        this.logToStderr(
+          `\nCherry-pick failed: ${sha.slice(0, 9)} ${subject}\n`,
+        );
+        this.logToStderr("Resolve the conflict then run:");
+        this.logToStderr("  git cherry-pick --continue");
+        this.logToStderr("  git cherry-pick --abort   (to cancel)");
+        this.exit(1);
+      }
+    }
+
+    exec(`git checkout ${currentBranch}`);
+    this.logToStderr(`\nDone: ${picked} picked`);
+  }
+}

package/src/lib/git.ts

@@ -0,0 +1,14 @@
+import { execSync } from "node:child_process";
+
+export function exec(cmd: string): string {
+  return execSync(cmd, { encoding: "utf8", stdio: "pipe" }).trim();
+}
+
+export function tryExec(cmd: string): { ok: boolean; output: string } {
+  try {
+    return { ok: true, output: exec(cmd) };
+  } catch (e: unknown) {
+    const err = e as { stderr?: string; message?: string };
+    return { ok: false, output: err.stderr ?? err.message ?? "" };
+  }
+}