@warren-dean/code-kit 0.3.4

package/hooks/hooks.json

@@ -0,0 +1,71 @@
+{
+  "description": "code-kit: lanes, protected paths with an approval log, spec-check and design gates, layer rules and the project's checks, from .claude/code-kit.json",
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|MultiEdit|Write|NotebookEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/guard-paths.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/guard-bash.mjs\"",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|MultiEdit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/post-edit-check.mjs\"",
+            "timeout": 90
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/lane-audit.mjs\"",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/stop-check.mjs\"",
+            "timeout": 600
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/stop-check.mjs\"",
+            "timeout": 600
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/lane-audit.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// PostToolUse (Bash) and part of Stop: shell commands can write files without going through the
+// path guard, so after each one every uncommitted change in the worktree is checked against the
+// same rules (lib/rules.mjs). Anything the actor may not write is reported for revert.
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { APPROVAL_LOG, LANE_FILE, actorFor, actorRoot, writeProblem } from './lib/rules.mjs';
+
+// The commit hook appends to the approval log and stages it; if that commit then fails, the
+// appended lines are left uncommitted. That is the only change to the log that is not a problem.
+function appendedOnly(root, rel) {
+  const committed = spawnSync('git', ['-C', root, 'show', `HEAD:${rel}`], { encoding: 'utf8' });
+  const before = committed.status === 0 ? committed.stdout : '';
+  try {
+    return readFileSync(join(root, rel), 'utf8').startsWith(before);
+  } catch {
+    return false; // deleted
+  }
+}
+
+export function changedFiles(root) {
+  const out =
+    spawnSync('git', ['-C', root, 'status', '--porcelain', '-uall', '--no-renames'], {
+      encoding: 'utf8',
+    }).stdout ?? '';
+  return out
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => l.slice(3).replace(/^"|"$/g, ''))
+    .filter((f) => !f.endsWith('/')) // a nested repository or worktree: its changes are its own
+    .filter((f) => f !== LANE_FILE);
+}
+
+export function auditProblems(input, config) {
+  const root = actorRoot(input);
+  if (!root) return [];
+  const actor = actorFor(input, root, config);
+  return changedFiles(root)
+    .filter((rel) => !(rel === APPROVAL_LOG && appendedOnly(root, rel)))
+    .map((rel) => [rel, writeProblem(actor, rel, root, config)])
+    .filter(([, problem]) => problem)
+    .map(([rel, problem]) => `${rel}: ${problem.split('\n')[0]}`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const { block, start } = await import('./lib/hook.mjs');
+  const { input, config, error } = start();
+  if (error) process.exit(0); // guard-paths and stop-check report an invalid config
+  const problems = auditProblems(input, config);
+  if (problems.length) {
+    block(
+      `These uncommitted changes break the ownership rules (.claude/code-kit.json). Revert them ` +
+        `(git checkout -- <file>, or delete new files) and do the work the permitted way:\n  ${problems.join('\n  ')}`,
+    );
+  }
+  process.exit(0);
+}

package/hooks/lib/adapters/context-graph.mjs

@@ -0,0 +1,34 @@
+// Context Graph (ctx) keeps a project's engineering context in `.ctx/`: ratified rules and concepts in
+// graph.ctx, settings in config.toml, the decisions agents record as they work in decisions.ctx, and
+// each file's card (its why) in cards.ctx. Every agent records decisions and cards for the files it
+// edits, so those two files are writable by any actor; the rules and settings
+// are the lead's, and changes to them go through the approval log. Ratifying a rule is a person's act,
+// signed with a commit trailer, so no Claude actor may write that trailer.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export default {
+  name: 'context-graph',
+  detect: (root) => existsSync(join(root, '.ctx')),
+  config: {
+    lead: ['.ctx/**'],
+    anyActor: ['.ctx/decisions.ctx', '.ctx/cards.ctx'],
+    protected: [
+      { glob: '.ctx/graph.ctx', approval: 'ctx', why: "Context Graph's rules and concepts" },
+      { glob: '.ctx/config.toml', approval: 'ctx', why: "Context Graph's settings" },
+    ],
+  },
+  shell: {
+    block: [
+      {
+        pattern: 'Ctx-Ratified-By\\s*[:=]',
+        why: "Ratifying a Context Graph rule is a person's act: they add the Ctx-Ratified-By trailer themselves, with a `!` git command.",
+      },
+    ],
+  },
+  setup: [
+    '.gitignore: .ctx/archive/, .ctx/bench/, .ctx/models/ and .ctx/serve.json (ctx working files, never committed)',
+    '.gitattributes: .ctx/decisions.ctx merge=union and .ctx/cards.ctx merge=union (lanes record decisions and cards on parallel branches; merging keeps them all)',
+    "CLAUDE.md: keep the Context Graph block and code-kit's section side by side, each pointing to the other",
+  ],
+};

package/hooks/lib/adapters/index.mjs

@@ -0,0 +1,34 @@
+// Adapters: what code-kit needs to know about another tool that shares the project, kept out of the core.
+// Each adapter says how to detect its tool and what that tool contributes to the rules:
+//
+//   name      the tool, and the key that switches it off in the config: "adapters": { "<name>": false }
+//   detect    (root) => true when the tool is in use in this project
+//   config    { lead?, anyActor?, protected? } merged into the effective config, like the kit's defaults
+//   shell     { block? } commands refused for every Claude actor, merged into shell.block
+//   setup     lines for init to apply or tell the person: ignore files, merge drivers, instructions
+//
+// The core only ever calls applyAdapters() and activeAdapters(); it never names a tool.
+import contextGraph from './context-graph.mjs';
+
+export const ADAPTERS = [contextGraph];
+
+/** Adapters detected in `root` and not switched off by the config's `adapters` map. */
+export function activeAdapters(raw, root) {
+  return ADAPTERS.filter((a) => raw.adapters?.[a.name] !== false && a.detect(root));
+}
+
+/** The effective config with every active adapter's contributions merged in. */
+export function applyAdapters(config, raw, root) {
+  const active = activeAdapters(raw, root);
+  if (!active.length) return { ...config, adapters: [] };
+  const merged = structuredClone(config);
+  for (const a of active) {
+    const c = a.config ?? {};
+    merged.lead.paths.push(...(c.lead ?? []));
+    merged.anyActor.push(...(c.anyActor ?? []));
+    merged.protected.push(...(c.protected ?? []));
+    merged.shell.block.push(...(a.shell?.block ?? []));
+  }
+  merged.adapters = active.map((a) => a.name);
+  return merged;
+}

package/hooks/lib/baseline.mjs

@@ -0,0 +1,23 @@
+// Brownfield code already breaks some layer rules. The baseline records those violations when the kit
+// is adopted, so only new ones block; it only ever shrinks (`code-kit baseline` rewrites it from the
+// code as it is, and the lead commits it like any other kit change).
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const BASELINE_FILE = '.claude/code-kit.baseline.json';
+
+/** { layers: { file: [problem, ...] } }; empty when there is no baseline. */
+export function loadBaseline(projectDir) {
+  const file = join(projectDir, BASELINE_FILE);
+  if (!existsSync(file)) return { layers: {} };
+  try {
+    const raw = JSON.parse(readFileSync(file, 'utf8'));
+    return { layers: raw.layers ?? {} };
+  } catch {
+    return { layers: {} }; // an unreadable baseline excuses nothing
+  }
+}
+
+/** The problems in `rel` that the baseline doesn't already record. */
+export const newProblems = (rel, problems, baseline) =>
+  problems.filter((p) => !(baseline.layers[rel] ?? []).includes(p));

package/hooks/lib/checks.mjs

@@ -0,0 +1,67 @@
+// The project's checks (config.checks): each runs when files matching it changed. Shared by the stop
+// hook (before an agent finishes) and `code-kit verify` (in CI, for a branch's changes).
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { globToRegExp, matchesAny } from './glob.mjs';
+
+/** The directories a check runs in: each changed one matching `each` that still exists, or the worktree. */
+function directories(check, files, root) {
+  if (!check.each) return [root];
+  const depth = check.each.split('/').length;
+  const dirs = files
+    .map((f) => f.split('/').slice(0, depth).join('/'))
+    .filter((d) => globToRegExp(check.each).test(d));
+  return [...new Set(dirs)].map((d) => join(root, d)).filter((d) => existsSync(d));
+}
+
+/** The first failure as { title, output }, or null. `actor` decides `owners`; the lead always may. */
+function runCheck(check, files, root, actor) {
+  if (check.owners && !(actor.kind === 'lead' || check.owners.includes(actor.lane))) {
+    return {
+      title: `The ${actor.label} changed ${check.name} files it does not own:`,
+      output: files.join('\n'),
+    };
+  }
+  for (const cwd of directories(check, files, root)) {
+    for (const command of check.run) {
+      const res = spawnSync(command, {
+        cwd,
+        shell: true,
+        encoding: 'utf8',
+        timeout: (check.timeoutSeconds ?? 240) * 1000,
+      });
+      const where = cwd === root ? '' : ` in ${cwd.slice(root.length + 1)}`;
+      if (res.status === 127) {
+        if (check.ifMissing === 'fail')
+          return {
+            title: `${check.name}: \`${command}\` is not installed${where}. Install it so the check can run.`,
+          };
+        return null; // not installed yet (fresh clone): the check can't run
+      }
+      if (res.error || res.status === null)
+        return {
+          title: `${check.name}: \`${command}\` did not finish${where} (${res.error?.code ?? res.signal}).`,
+        };
+      if (res.status !== 0)
+        return {
+          title: `${check.name}: \`${command}\` fails${where}. Fix it:`,
+          output: res.stdout + res.stderr,
+        };
+    }
+  }
+  return null;
+}
+
+/** Runs every check whose files changed, in order; the first failure, or null when all pass. */
+export function runChecks(config, changed, root, actor) {
+  for (const check of config.checks) {
+    const files = changed.filter(
+      (f) => matchesAny(f, check.files) && !matchesAny(f, check.exclude),
+    );
+    if (!files.length) continue;
+    const failure = runCheck(check, files, root, actor);
+    if (failure) return failure;
+  }
+  return null;
+}

package/hooks/lib/config.mjs

@@ -0,0 +1,211 @@
+// The project's rules live in .claude/code-kit.json. The hooks read it from the project the session
+// was opened in; a project without one is not governed by the kit, and an invalid one fails closed.
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ADAPTERS, applyAdapters } from './adapters/index.mjs';
+
+export const CONFIG_FILE = '.claude/code-kit.json';
+// Claude's own memory and session scratchpad, which the lead always writes.
+export const CLAUDE_OWN = [
+  '~/.claude/projects/*/memory/**',
+  '/private/tmp/claude-*/**',
+  '/tmp/claude-*/**',
+];
+const KIT = { glob: '.claude/**', approval: 'kit', why: 'the rules that constrain agents' };
+
+/** `{ config }` when the project has a valid config, `{ error }` when it is invalid, `{}` when it has none. */
+export function loadConfig(projectDir) {
+  const file = join(projectDir, CONFIG_FILE);
+  if (!existsSync(file)) return {};
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (e) {
+    return { error: `${CONFIG_FILE} is not valid JSON: ${e.message}` };
+  }
+  const problems = validate(raw);
+  if (problems.length) return { error: `${CONFIG_FILE} is invalid:\n  ${problems.join('\n  ')}` };
+  return { config: effectiveConfig(raw, projectDir) };
+}
+
+/** The rules the hooks enforce: the project's config, the kit's defaults, and any active adapters. */
+export const effectiveConfig = (raw, root) => applyAdapters(withDefaults(raw), raw, root);
+
+/** The engine's fixed rules, merged into the project's: the kit and Claude's own files belong to the lead. */
+export function withDefaults(c) {
+  return {
+    ...c,
+    lead: {
+      paths: [...c.lead.paths, '.claude/**'],
+      outside: [...(c.lead.outside ?? []), ...CLAUDE_OWN],
+    },
+    anyActor: [...(c.anyActor ?? []), '.claude/state/**'],
+    protected: [KIT, ...(c.protected ?? []).filter((p) => p.glob !== KIT.glob)],
+    layers: c.layers ?? [],
+    importAliases: c.importAliases ?? {},
+    shell: { block: c.shell?.block ?? [], restricted: c.shell?.restricted ?? [] },
+    postEdit: c.postEdit ?? [],
+    checks: c.checks ?? [],
+    branches: { protected: c.branches?.protected ?? ['main', 'master'] },
+  };
+}
+
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const isStr = (v) => typeof v === 'string' && v.length > 0;
+const isList = (v) => Array.isArray(v) && v.every(isStr);
+const isRegExp = (v) => {
+  try {
+    return isStr(v) && Boolean(new RegExp(v));
+  } catch {
+    return false;
+  }
+};
+
+/** Every problem with a parsed config, as readable sentences; empty when it is valid. */
+export function validate(c) {
+  if (!isObj(c)) return ['the config must be a JSON object'];
+  const p = [];
+  const need = (ok, msg) => {
+    if (!ok) p.push(msg);
+    return ok;
+  };
+  const each = (key, fn) => {
+    if (c[key] === undefined) return;
+    if (!need(Array.isArray(c[key]), `"${key}" must be a list`)) return;
+    c[key].forEach((item, i) =>
+      isObj(item) ? fn(item, `${key}[${i}]`) : p.push(`${key}[${i}] must be an object`),
+    );
+  };
+  need(c.version === 1, '"version" must be 1');
+  // A brownfield project may have no specs yet: then there is no spec-check gate.
+  need(c.docs === undefined || isObj(c.docs), '"docs" must be an object');
+  for (const k of ['specs', 'principles', 'plan'])
+    need(c.docs?.[k] === undefined || isStr(c.docs[k]), `"docs.${k}" must be a path`);
+  need(isObj(c.lead) && isList(c.lead?.paths), '"lead.paths" must be a list of globs');
+  need(
+    c.lead?.outside === undefined || isList(c.lead.outside),
+    '"lead.outside" must be a list of globs',
+  );
+  need(c.anyActor === undefined || isList(c.anyActor), '"anyActor" must be a list of globs');
+  validateLanes(c, need);
+  const lanes = Object.keys(isObj(c.lanes) ? c.lanes : {});
+  each('protected', (e, at) => {
+    need(isStr(e.glob) && isStr(e.why), `${at} needs "glob" and "why"`);
+    need(
+      /^[a-z][a-z0-9-]*$/.test(e.approval ?? ''),
+      `${at}.approval must be a short lower-case name`,
+    );
+  });
+  if (c.designGate !== undefined) validateDesignGate(c.designGate, need);
+  validateLayers(c, need, each);
+  if (c.shell !== undefined) validateShell(c.shell, lanes, need);
+  each('postEdit', (e, at) => {
+    need(
+      isList(e.files) && isStr(e.run),
+      `${at} needs "files" (globs) and "run" (a command; {file} is the edited file)`,
+    );
+    need(e.exclude === undefined || isList(e.exclude), `${at}.exclude must be a list of globs`);
+  });
+  each('checks', (e, at) => validateCheck(e, at, lanes, need));
+  const known = ADAPTERS.map((a) => a.name);
+  need(
+    c.adapters === undefined ||
+      (isObj(c.adapters) &&
+        Object.entries(c.adapters).every(([k, v]) => known.includes(k) && typeof v === 'boolean')),
+    `"adapters" must map adapter names (${known.join(', ')}) to true or false`,
+  );
+  need(
+    c.branches === undefined || isList(c.branches?.protected),
+    '"branches.protected" must be a list of branch names',
+  );
+  return p;
+}
+
+function validateLanes(c, need) {
+  if (!need(isObj(c.lanes), '"lanes" must be an object (it may be empty)')) return;
+  const agents = new Set();
+  for (const [name, lane] of Object.entries(c.lanes)) {
+    if (!need(isObj(lane), `lanes.${name} must be an object`)) continue;
+    need(
+      isList(lane.paths) && lane.paths.length > 0,
+      `lanes.${name}.paths must list the globs the lane owns`,
+    );
+    need(isStr(lane.agent), `lanes.${name}.agent must name the lane's agent`);
+    need(
+      lane.exclude === undefined || isList(lane.exclude),
+      `lanes.${name}.exclude must be a list of globs`,
+    );
+    need(!agents.has(lane.agent), `lanes.${name}.agent "${lane.agent}" is used by another lane`);
+    agents.add(lane.agent);
+  }
+}
+
+function validateDesignGate(g, need) {
+  need(
+    isObj(g) && isStr(g.register) && isStr(g.howTo),
+    '"designGate" needs "register" and "howTo"',
+  );
+  const ok =
+    Array.isArray(g?.screens) &&
+    g.screens.every((s) => isStr(s?.glob) && (s.not === undefined || isRegExp(s.not)));
+  need(ok, '"designGate.screens" must be a list of { glob, not? (a regular expression) }');
+}
+
+function validateLayers(c, need, each) {
+  const names = new Set((Array.isArray(c.layers) ? c.layers : []).map((l) => l?.name));
+  each('layers', (l, at) => {
+    need(isStr(l.name) && isList(l.paths), `${at} needs "name" and "paths"`);
+    need(
+      isList(l.mayImport),
+      `${at}.mayImport must list the layers it may depend on (may be empty)`,
+    );
+    for (const n of isList(l.mayImport) ? l.mayImport : [])
+      need(names.has(n), `${at}.mayImport names an unknown layer "${n}"`);
+    need(
+      l.denyPackages === undefined || isList(l.denyPackages),
+      `${at}.denyPackages must be a list of globs`,
+    );
+  });
+  const aliases = c.importAliases;
+  need(
+    aliases === undefined || (isObj(aliases) && Object.values(aliases).every(isStr)),
+    '"importAliases" must map import prefixes to repository paths',
+  );
+}
+
+function validateShell(s, lanes, need) {
+  if (!need(isObj(s), '"shell" must be an object')) return;
+  const rule = (r) => isObj(r) && isRegExp(r.pattern) && isStr(r.why);
+  need(
+    s.block === undefined || (Array.isArray(s.block) && s.block.every(rule)),
+    '"shell.block" must be a list of { pattern, why }',
+  );
+  const restricted =
+    s.restricted === undefined ||
+    (Array.isArray(s.restricted) && s.restricted.every((r) => rule(r) && isList(r.lanes)));
+  need(restricted, '"shell.restricted" must be a list of { pattern, lanes, why }');
+  for (const r of Array.isArray(s.restricted) ? s.restricted : []) {
+    for (const l of isList(r?.lanes) ? r.lanes : [])
+      need(lanes.includes(l), `"shell.restricted" names an unknown lane "${l}"`);
+  }
+}
+
+function validateCheck(e, at, lanes, need) {
+  need(
+    isStr(e.name) && isList(e.files) && isList(e.run) && e.run.length > 0,
+    `${at} needs "name", "files" (globs) and "run" (commands)`,
+  );
+  need(e.exclude === undefined || isList(e.exclude), `${at}.exclude must be a list of globs`);
+  need(e.each === undefined || isStr(e.each), `${at}.each must be a directory glob`);
+  need(
+    e.ifMissing === undefined || ['skip', 'fail'].includes(e.ifMissing),
+    `${at}.ifMissing must be "skip" or "fail"`,
+  );
+  need(
+    e.timeoutSeconds === undefined || (Number.isInteger(e.timeoutSeconds) && e.timeoutSeconds > 0),
+    `${at}.timeoutSeconds must be a positive whole number`,
+  );
+  for (const l of isList(e.owners) ? e.owners : [])
+    need(lanes.includes(l), `${at}.owners names an unknown lane "${l}"`);
+  need(e.owners === undefined || isList(e.owners), `${at}.owners must be a list of lanes`);
+}

package/hooks/lib/dependencies.mjs

@@ -0,0 +1,129 @@
+// New dependencies: which packages a shell command adds, and which files installing them changes.
+// Each package needs a person's approval (`dep-<package>`), which also covers those files.
+import { basename } from 'node:path';
+
+// What installing a package rewrites: manifests and lockfiles, wherever they sit.
+const DEPENDENCY_FILES = new Set([
+  'package.json',
+  'package-lock.json',
+  'npm-shrinkwrap.json',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+  'bun.lock',
+  'bun.lockb',
+  'pyproject.toml',
+  'uv.lock',
+  'poetry.lock',
+  'Pipfile',
+  'Pipfile.lock',
+  'Cargo.toml',
+  'Cargo.lock',
+  'go.mod',
+  'go.sum',
+  'Gemfile',
+  'Gemfile.lock',
+]);
+
+export const isDependencyFile = (rel) => DEPENDENCY_FILES.has(basename(rel));
+
+export const DEPENDENCY_APPROVAL = 'dep-';
+
+/** The approval a package needs: `dep-<name>`, with `/` as `+` so a scoped name stays one file. */
+export const dependencyApproval = (pkg) =>
+  `${DEPENDENCY_APPROVAL}${pkg.replace(/\//g, '+').replace(/[^\w.@+-]/g, '_')}`;
+
+const js = (name) => name.replace(/(?<=.)@.*$/, ''); // lodash@4, @scope/pkg@^1
+const py = (name) => name.split(/[[<>=!~;\s]/)[0]; // httpx>=0.27, requests[socks]
+const at = (name) => name.replace(/@.*$/, ''); // serde@1, example.com/m@v1
+
+// Each package manager: the subcommands that add packages, the flags that take a value (so the value
+// isn't read as a package), the words that take one argument before the subcommand, and how a version
+// is written onto a name.
+const MANAGERS = {
+  npm: {
+    adds: ['install', 'i', 'add', 'in'],
+    values: ['--workspace', '-w', '--prefix', '--registry', '--tag', '--save-prefix'],
+    name: js,
+  },
+  pnpm: {
+    adds: ['add', 'install', 'i'],
+    values: ['--filter', '-F', '--dir', '-C', '--registry', '--save-prefix'],
+    name: js,
+  },
+  yarn: { adds: ['add'], values: ['--cwd', '--registry'], before: ['workspace'], name: js },
+  bun: { adds: ['add', 'install', 'i'], values: ['--cwd', '--registry'], name: js },
+  pip: {
+    adds: ['install'],
+    values: [
+      '-r',
+      '--requirement',
+      '-c',
+      '--constraint',
+      '-e',
+      '--editable',
+      '-i',
+      '--index-url',
+      '--extra-index-url',
+      '-f',
+      '--find-links',
+      '-t',
+      '--target',
+      '--prefix',
+      '--root',
+    ],
+    name: py,
+    local: ['.'],
+  },
+  uv: { adds: ['add'], values: ['--group', '--optional', '--package', '--directory'], name: py },
+  poetry: { adds: ['add'], values: ['--group', '-G', '--directory', '-C'], name: at },
+  cargo: {
+    adds: ['add'],
+    values: ['--features', '-F', '--package', '-p', '--path', '--git', '--rename'],
+    name: at,
+  },
+  go: { adds: ['get'], values: [], name: at },
+  bundle: { adds: ['add'], values: ['--version', '-v', '--group', '-g', '--source'], name: at },
+};
+MANAGERS.pip3 = MANAGERS.pip;
+
+/** The packages `cmd` adds as dependencies, in order: none for a bare install or a requirements file. */
+export function addedPackages(cmd) {
+  const found = [];
+  for (const segment of cmd.split(/&&|\|\||[;|\n]/)) {
+    const tokens = segment
+      .trim()
+      .split(/\s+/)
+      .map((t) => t.replace(/^["']|["']$/g, ''));
+    tokens.forEach((token, i) => {
+      const manager = MANAGERS[basename(token)];
+      if (manager) found.push(...packagesAfter(tokens.slice(i + 1), manager));
+    });
+  }
+  return [...new Set(found)];
+}
+
+// The words after a package manager's name: its subcommand must be one that adds packages, and the
+// words after that, other than flags and their values, are the packages.
+function packagesAfter(words, manager) {
+  let i = 0;
+  const skipFlag = () => {
+    const word = words[i++];
+    if (manager.values.includes(word)) i++;
+  };
+  while (i < words.length && words[i].startsWith('-')) skipFlag();
+  if (manager.before?.includes(words[i])) i += 2; // yarn workspace <name> add …
+  while (i < words.length && words[i].startsWith('-')) skipFlag();
+  if (!manager.adds.includes(words[i])) return [];
+  i++;
+  const packages = [];
+  while (i < words.length) {
+    if (words[i].startsWith('-')) skipFlag();
+    // a redirect ends the arguments
+    else if (/^[>&<]|^\d*>/.test(words[i])) break;
+    else {
+      const word = words[i++];
+      if (!manager.local?.includes(word)) packages.push(manager.name(word));
+    }
+  }
+  return packages.filter(Boolean);
+}