@cbartens/bkit 5.0.0 → 5.0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.bkit/README.md +12 -16
- package/.bkit/core/.agents/rules.md +57 -57
- package/.bkit/core/.bkit/README.md +11 -15
- package/.bkit/core/.bkit/cloud.md +22 -30
- package/.bkit/core/.bkit/comparison.md +36 -28
- package/.bkit/core/.bkit/install.md +55 -150
- package/.bkit/core/.bkit/jsonl.md +5 -5
- package/.bkit/core/.bkit/providers.md +6 -3
- package/.bkit/core/.bkit/templates.md +9 -7
- package/.bkit/core/.bkit/trackers.md +1 -1
- package/.bkit/core/.bkit/workflows.md +7 -3
- package/.bkit/core/engine/checks/after/auth.ts +16 -114
- package/.bkit/core/engine/checks/after/ci-yml.ts +36 -74
- package/.bkit/core/engine/checks/after/github.ts +1 -1
- package/.bkit/core/engine/checks/after/index.ts +158 -184
- package/.bkit/core/engine/checks/after/suppression.ts +53 -0
- package/.bkit/core/engine/checks/before/env.ts +5 -19
- package/.bkit/core/engine/checks/before/files.ts +2 -0
- package/.bkit/core/engine/cli.ts +4 -8
- package/.bkit/core/engine/commands/install/doctor.ts +9 -2
- package/.bkit/core/engine/commands/install/install.ts +24 -2
- package/.bkit/core/engine/commands/install/uninstall.ts +56 -1
- package/.bkit/core/engine/commands/install/upgrade.ts +14 -3
- package/.bkit/core/engine/commands/lib.ts +4 -3
- package/.bkit/core/engine/install/cloud-env.ts +4 -2
- package/.bkit/core/engine/install/modules/cloud.ts +3 -4
- package/.bkit/core/engine/install/modules/core.ts +33 -13
- package/.bkit/core/engine/install/modules/opencode.ts +34 -13
- package/.bkit/core/engine/install/payload-links.ts +150 -0
- package/.bkit/core/engine/install/template-copies.ts +1 -1
- package/.bkit/core/engine/shared/egress.ts +1 -1
- package/.bkit/core/workflows/bkit-debug.md +19 -12
- package/.bkit/shared/.bkit/.env.example +43 -36
- package/.bkit/shared/.claude/bkit-cloud.md +1 -1
- package/.bkit/shared/.cursor/bkit-cloud.md +2 -2
- package/.bkit/shared/.opencode/opencode.json +3 -1
- package/.bkit/shared/docs/deployments.md +7 -10
- package/.bkit/shared/docs/security.md +1 -1
- package/.bkit/shared/gitignore +5 -0
- package/.bkit/templates/.claude/hooks/bkit-cloud-bootstrap.sh +0 -5
- package/.bkit/templates/.cursor/Dockerfile +1 -1
- package/.bkit/templates/.cursor/environment.json +1 -1
- package/.bkit/templates/.github/renovate.json5 +0 -15
- package/.bkit/templates/.github/workflows/bkit-ci.yml +7 -24
- package/.bkit/templates/.github/workflows/bkit-cloud.yml +0 -2
- package/.bkit/templates/.github/workflows/bkit-renovate.yml +7 -10
- package/.bkit/templates/scripts/secrets/bkit-secrets.mjs +125 -12
- package/CHANGELOG.md +37 -0
- package/README.md +96 -38
- package/dist/checks/after/auth.js +16 -108
- package/dist/checks/after/ci-yml.js +30 -67
- package/dist/checks/after/github.js +1 -1
- package/dist/checks/after/index.js +138 -154
- package/dist/checks/after/suppression.js +39 -0
- package/dist/checks/before/env.js +5 -15
- package/dist/checks/before/files.js +2 -0
- package/dist/cli.js +4 -8
- package/dist/commands/install/doctor.js +4 -2
- package/dist/commands/install/install.js +16 -2
- package/dist/commands/install/uninstall.js +45 -1
- package/dist/commands/install/upgrade.js +14 -3
- package/dist/commands/lib.js +4 -3
- package/dist/install/cloud-env.js +4 -2
- package/dist/install/modules/cloud.js +3 -4
- package/dist/install/modules/core.js +33 -13
- package/dist/install/modules/opencode.js +34 -14
- package/dist/install/payload-links.js +119 -0
- package/dist/install/template-copies.js +1 -1
- package/dist/shared/egress.js +1 -1
- package/package.json +25 -3
- package/.bkit/core/engine/checks/after/vercel.ts +0 -101
- package/dist/checks/after/vercel.js +0 -102
|
@@ -24,6 +24,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
|
|
|
24
24
|
|
|
25
25
|
const VERCEL_API = "https://api.vercel.com";
|
|
26
26
|
const SUPABASE_API = "https://api.supabase.com";
|
|
27
|
+
const CURSOR_API = "https://api.cursor.com";
|
|
27
28
|
// Seconds a remote "last updated" may trail the recorded push before it counts as an outside write.
|
|
28
29
|
const CLOCK_SLACK = 120;
|
|
29
30
|
const STATE_FILE = "bkit-secrets-state.json";
|
|
@@ -97,8 +98,10 @@ async function api(base, token, method, route, body) {
|
|
|
97
98
|
|
|
98
99
|
// ── Stores ────────────────────────────────────────────────────────────────────
|
|
99
100
|
// open(ctx) → { target, list(wanted), write(entries, onWritten), remove(names) }, or throws Skip.
|
|
100
|
-
// list → Map NAME → { readable, fp?, updated? }: readable=false is a
|
|
101
|
-
// the state file); readable with no fp means that value could not be read.
|
|
101
|
+
// ctx = { env, value, store, root }. list → Map NAME → { readable, fp?, updated? }: readable=false is a
|
|
102
|
+
// write-only store (parity from the state file); readable with no fp means that value could not be read.
|
|
103
|
+
// Optional `protects(name)` on the adapter or its handle → true for platform-reserved names (never
|
|
104
|
+
// written or deleted). A store is a built-in type (below) or `type: "custom"` + `module` (see loadConfig).
|
|
102
105
|
|
|
103
106
|
const STORES = {
|
|
104
107
|
github: {
|
|
@@ -393,6 +396,70 @@ const STORES = {
|
|
|
393
396
|
};
|
|
394
397
|
},
|
|
395
398
|
},
|
|
399
|
+
|
|
400
|
+
cursor: {
|
|
401
|
+
label: "Cursor Cloud Agents secrets",
|
|
402
|
+
perEnv: false,
|
|
403
|
+
async open({ value, store }) {
|
|
404
|
+
const token =
|
|
405
|
+
process.env.CURSOR_API_KEY || value("CURSOR_API_KEY") || value("BKIT_CURSOR_API_KEY");
|
|
406
|
+
if (!token) throw new Error("need CURSOR_API_KEY (or BKIT_CURSOR_API_KEY) in the env files");
|
|
407
|
+
const call = (method, route, body) => api(CURSOR_API, token, method, route, body);
|
|
408
|
+
let envId = store.environmentId;
|
|
409
|
+
const envName = store.environment;
|
|
410
|
+
if (!envId) {
|
|
411
|
+
if (!envName)
|
|
412
|
+
throw new Error("need store option `environment` (name) or `environmentId` for cursor");
|
|
413
|
+
const items = (await call("GET", "/v1/environments"))?.items ?? [];
|
|
414
|
+
const match = items.find((e) => e.id === envName || e.name === envName);
|
|
415
|
+
if (!match)
|
|
416
|
+
throw new Error(
|
|
417
|
+
`Cursor environment "${envName}" not found (available: ${items.map((e) => e.name ?? e.id).join(", ") || "none"})`,
|
|
418
|
+
);
|
|
419
|
+
envId = match.id;
|
|
420
|
+
}
|
|
421
|
+
const base = `/v1/environments/${encodeURIComponent(envId)}/secrets`;
|
|
422
|
+
// Prefetch so `protects` can hide build_secret names during the engine's write pass.
|
|
423
|
+
let versions = (await call("GET", base))?.items ?? [];
|
|
424
|
+
// A name with several repo-scoped versions returns 409 without an explicit `?id=`.
|
|
425
|
+
const assertSingle = (n) => {
|
|
426
|
+
if (versions.filter((v) => v.name === n).length > 1)
|
|
427
|
+
throw new Error(
|
|
428
|
+
`${n}: several Cursor versions share this name (repo-scoped); the API needs an explicit version id — remove the extra versions in the Cursor dashboard`,
|
|
429
|
+
);
|
|
430
|
+
};
|
|
431
|
+
return {
|
|
432
|
+
target: envName || envId,
|
|
433
|
+
// build_secret versions exist only via the dashboard and cannot be written through the API.
|
|
434
|
+
protects: (n) => versions.some((v) => v.name === n && v.type === "build_secret"),
|
|
435
|
+
async list() {
|
|
436
|
+
versions = (await call("GET", base))?.items ?? [];
|
|
437
|
+
const live = new Map();
|
|
438
|
+
for (const v of versions)
|
|
439
|
+
live.set(v.name, {
|
|
440
|
+
readable: false,
|
|
441
|
+
updated: v.createdAt ? Date.parse(v.createdAt) / 1000 : undefined,
|
|
442
|
+
});
|
|
443
|
+
return live;
|
|
444
|
+
},
|
|
445
|
+
async write(list, onWritten) {
|
|
446
|
+
for (const e of list) {
|
|
447
|
+
assertSingle(e.name);
|
|
448
|
+
const type =
|
|
449
|
+
e.option === "environment_variable" ? "environment_variable" : "runtime_secret";
|
|
450
|
+
await call("PUT", `${base}/${encodeURIComponent(e.name)}`, { value: e.value, type });
|
|
451
|
+
onWritten(e.name);
|
|
452
|
+
}
|
|
453
|
+
},
|
|
454
|
+
async remove(names) {
|
|
455
|
+
for (const n of names) {
|
|
456
|
+
assertSingle(n);
|
|
457
|
+
await call("DELETE", `${base}/${encodeURIComponent(n)}`);
|
|
458
|
+
}
|
|
459
|
+
},
|
|
460
|
+
};
|
|
461
|
+
},
|
|
462
|
+
},
|
|
396
463
|
};
|
|
397
464
|
|
|
398
465
|
function readJson(p) {
|
|
@@ -418,6 +485,53 @@ function vercelCliToken() {
|
|
|
418
485
|
|
|
419
486
|
const CONFIG_KEYS = new Set(["sources", "stores", "protected", "optional", "secrets"]);
|
|
420
487
|
const SECRET_KEYS = new Set(["to", "from", "derive", "manual"]);
|
|
488
|
+
const CUSTOM_STORE = "custom";
|
|
489
|
+
|
|
490
|
+
// Resolve a store's adapter: a built-in STORES entry, or `type: "custom"` + `module` (repo-local).
|
|
491
|
+
async function adapterFor(dir, name, opts) {
|
|
492
|
+
const type = opts.type ?? name;
|
|
493
|
+
if (type !== CUSTOM_STORE) {
|
|
494
|
+
if (!STORES[type])
|
|
495
|
+
throw new Error(
|
|
496
|
+
`bkit-secrets.config.mjs: store "${name}" has unknown type "${type}" (known: ${Object.keys(STORES).join(", ")}, ${CUSTOM_STORE})`,
|
|
497
|
+
);
|
|
498
|
+
return STORES[type];
|
|
499
|
+
}
|
|
500
|
+
if (!opts.module)
|
|
501
|
+
throw new Error(
|
|
502
|
+
`bkit-secrets.config.mjs: store "${name}" type "${CUSTOM_STORE}" needs a "module"`,
|
|
503
|
+
);
|
|
504
|
+
const file = path.resolve(dir, opts.module);
|
|
505
|
+
if (!fs.existsSync(file))
|
|
506
|
+
throw new Error(
|
|
507
|
+
`bkit-secrets.config.mjs: store "${name}" module "${opts.module}" not found at ${file}`,
|
|
508
|
+
);
|
|
509
|
+
const mod = await import(`${pathToFileURL(file).href}?t=${Date.now()}`);
|
|
510
|
+
const adapter = mod.default ?? mod;
|
|
511
|
+
const bad = (msg) => {
|
|
512
|
+
throw new Error(`bkit-secrets.config.mjs: store "${name}" module "${opts.module}": ${msg}`);
|
|
513
|
+
};
|
|
514
|
+
if (!adapter || typeof adapter !== "object") bad("default export must be an object");
|
|
515
|
+
if (typeof adapter.label !== "string") bad('needs a "label" string');
|
|
516
|
+
if (typeof adapter.open !== "function") bad('needs an "open" function');
|
|
517
|
+
if (adapter.perEnv !== undefined && typeof adapter.perEnv !== "boolean")
|
|
518
|
+
bad('"perEnv" must be a boolean');
|
|
519
|
+
for (const k of ["protects", "setOptions"])
|
|
520
|
+
if (adapter[k] !== undefined && typeof adapter[k] !== "function")
|
|
521
|
+
bad(`"${k}" must be a function`);
|
|
522
|
+
return adapter;
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
// The handle an adapter's open() returns: the engine's list / write / remove contract.
|
|
526
|
+
function assertHandle(label, handle) {
|
|
527
|
+
const bad = (msg) => {
|
|
528
|
+
throw new Error(`${label}: open() ${msg}`);
|
|
529
|
+
};
|
|
530
|
+
if (!handle || typeof handle !== "object") bad("must return an object");
|
|
531
|
+
if (handle.target === undefined) bad('must return a "target"');
|
|
532
|
+
for (const m of ["list", "write", "remove"])
|
|
533
|
+
if (typeof handle[m] !== "function") bad(`must return a "${m}" function`);
|
|
534
|
+
}
|
|
421
535
|
|
|
422
536
|
// Validated config for repo tooling that needs the same scope (e.g. "which keys reach EAS"):
|
|
423
537
|
// const cfg = await loadConfig("scripts/secrets"); secretsFor(cfg, "eas")
|
|
@@ -428,14 +542,9 @@ export async function loadConfig(dir) {
|
|
|
428
542
|
if (!CONFIG_KEYS.has(k)) throw new Error(`bkit-secrets.config.mjs: unknown key "${k}"`);
|
|
429
543
|
if (!cfg.sources?.preview)
|
|
430
544
|
throw new Error("bkit-secrets.config.mjs: sources.preview is required");
|
|
431
|
-
const stores =
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
throw new Error(
|
|
435
|
-
`bkit-secrets.config.mjs: store "${name}" has unknown type "${type}" (known: ${Object.keys(STORES).join(", ")})`,
|
|
436
|
-
);
|
|
437
|
-
return { name, opts, adapter: STORES[type] };
|
|
438
|
-
});
|
|
545
|
+
const stores = [];
|
|
546
|
+
for (const [name, opts] of Object.entries(cfg.stores ?? {}))
|
|
547
|
+
stores.push({ name, opts, adapter: await adapterFor(dir, name, opts) });
|
|
439
548
|
const secrets = Object.entries(cfg.secrets ?? {}).map(([name, spec]) => {
|
|
440
549
|
const s = typeof spec === "string" || Array.isArray(spec) ? { to: spec } : spec;
|
|
441
550
|
for (const k of Object.keys(s))
|
|
@@ -512,13 +621,17 @@ function compare(fp, live, rec) {
|
|
|
512
621
|
|
|
513
622
|
async function runTarget({ mode, store, env, cfg, src, state, root, log }) {
|
|
514
623
|
const { adapter, name: storeName, opts } = store;
|
|
624
|
+
let handle;
|
|
515
625
|
const isProtected = (n) =>
|
|
516
|
-
cfg.protected.has(n) ||
|
|
626
|
+
cfg.protected.has(n) ||
|
|
627
|
+
toArray(opts.protect).includes(n) ||
|
|
628
|
+
Boolean(adapter.protects?.(n)) ||
|
|
629
|
+
Boolean(handle?.protects?.(n));
|
|
517
630
|
const scoped = cfg.secrets.filter((s) => s.to.some((t) => t.store === storeName));
|
|
518
631
|
const value = (k) => src.value(k, env);
|
|
519
|
-
let handle;
|
|
520
632
|
try {
|
|
521
633
|
handle = await adapter.open({ env, value, store: opts, root });
|
|
634
|
+
assertHandle(adapter.label, handle);
|
|
522
635
|
} catch (err) {
|
|
523
636
|
if (err instanceof Skip) {
|
|
524
637
|
log(
|
package/CHANGELOG.md
CHANGED
|
@@ -6,6 +6,43 @@ Format: `## [version] — YYYY-MM-DD`
|
|
|
6
6
|
|
|
7
7
|
---
|
|
8
8
|
|
|
9
|
+
## [5.0.2] — 2026-10-12
|
|
10
|
+
|
|
11
|
+
### Added
|
|
12
|
+
|
|
13
|
+
- **Pluggable secrets-store adapters and a built-in Cursor store** (#529). `bkit-secrets.config.mjs` gains `type: "custom"` + `module`, which loads a repo-local adapter (validated at load, its `open()` handle validated at run) so a new platform needs no upstream engine change and `bkit-secrets.mjs` stays byte-identical across repos. A new built-in `cursor` store syncs Cursor Cloud Agents secrets over the REST API v1 (`cursor:environment_variable` per-row option): environment by name or id, write-only parity from the state file, a `protects(name)` handle guard for platform-reserved names such as `build_secret`, and a pre-checked multi-version ambiguity guard.
|
|
14
|
+
- **OpenCode's fetch tool is gated from the same network allowlist as its shell** (#381). `permission.webfetch` becomes a URL-keyed map (`{ "*": "ask" }`) and `injectOpencodeDerivedAllows` adds `*{domain}*: allow` per resolved base (last-match-wins), mirroring the existing curl/wget globs — so a host on the allowlist no longer prompts on `%WebFetch`. Claude gates the fetch tool and not the shell; OpenCode now gates both, and the V1 object syntax is honoured natively and by 2.0's compat layer. Cursor shares the allowlist artifact and Codex inherits it (advisory — it cannot prompt). A new cross-surface parity test requires every derived base to reach Claude's WebFetch set, OpenCode's webfetch map **and** curl/wget globs, and Cursor's allowlist.
|
|
15
|
+
- **bkit's own CI adopts release-PR mirror mode** (#528). A same-repo PR on `dev` / `release/*` against the default branch mirrors the push run onto the PR head (`bkit runs mirror --head=$PR_HEAD_SHA --branch=dev --max-minutes=170`) and the capstone checks out and installs that head. Every `dev` push now runs the full level (the merged-PR light arm is removed). The template scaffold and `docs/deployments.md` widen the predicate to `dev|release/*`.
|
|
16
|
+
|
|
17
|
+
### Changed
|
|
18
|
+
|
|
19
|
+
- **README and package metadata lead with audience, proof and CI template** (#505). A context-map image, a phase-true features grid and a pipeline diagram replace the earlier marketing copy; marketing numbers are rounded down and prefixed with `>`; `package.json` npm metadata (description, keywords, repository, bugs, homepage, publishConfig) is filled in for the public registry.
|
|
20
|
+
- **PAT-type guidance across the secrets surfaces.** `.bkit/.env.example` and the preflight / post-install advisories now carry the decision rule — a fine-grained PAT when every target repo sits under one owner, a classic PAT when one token must span owners — plus a `launchd.env` re-sync warning after rotation (GUI and daemon apps do not inherit direnv exports). Matching wording lands in `bkit-renovate.yml`, `bkit-secrets.config.mjs` and `docs/security.md`.
|
|
21
|
+
- **OpenCode environment handling docs** now explain how `{env:…}` resolves in the background service and that `.bkit/.env` is merged into child environments per repo.
|
|
22
|
+
|
|
23
|
+
### Fixed
|
|
24
|
+
|
|
25
|
+
- **A targeted `bkit uninstall --<module>` no longer leaves `.bkit/version` stale.** The uninstall deleted the module's files but kept their canonical hashes in the install-state manifest, so the very next `bkit check` — the documented CI drift gate — reported write-drift on `.bkit/version` and exited 1 until the consumer re-ran `bkit install`. A targeted uninstall now recomputes and rewrites the version pin, pruning the deleted paths, exactly as the core install and upgrade paths do. A full/core uninstall still deletes the manifest for a zero footprint.
|
|
26
|
+
|
|
27
|
+
---
|
|
28
|
+
|
|
29
|
+
## [5.0.1] — 2026-10-12
|
|
30
|
+
|
|
31
|
+
### Changed
|
|
32
|
+
|
|
33
|
+
- **`@cbartens/bkit` publishes to the public npm registry** (#408). Installs resolve from `https://registry.npmjs.org` with no token, no `@cbartens:registry` `.npmrc` mapping and no GitHub Packages auth; GitHub Packages is no longer updated. Releases publish through npm OIDC trusted publishing with a signed build-provenance attestation.
|
|
34
|
+
|
|
35
|
+
### Added
|
|
36
|
+
|
|
37
|
+
- **Payload view links: `.bkit/core` and `.bkit/shared` symlink into the installed package** (#525). `bkit install` and `bkit upgrade` create both as relative links to `node_modules/@cbartens/bkit/.bkit/{core,shared}`, so the workflow / prompt / hook sources are browsable from the consumer repo. Views, not copies — always the installed version, never hashed, and `bkit check` flags a missing or broken link as drift. Both paths join the managed `.gitignore` block (they dangle on a fresh clone or in CI) and `BKIT_GITIGNORE_LINES`. A real directory or file at either path is never clobbered (advisory `payload-link-real-dir`); a platform that refuses symlinks (Windows without Developer Mode) falls back to a junction, then to advisory `payload-link-failed` — never a failure. `bkit uninstall` removes the links (symlinks only). Hand-rolled links from before this release keep working — re-pointed only if they resolve elsewhere — and the duplicates advisory asks you to drop the consumer-side `.gitignore` lines the managed block now covers.
|
|
38
|
+
- **Dismiss an advisory per package.** A detector can be right in general and still fire where the condition is deliberately not applicable — a rule-linter whose test titles mention `@live`, an integration lane mocked by design. `package.json` `bkit.ignoreAdvisories: string[]` opts a package out of an advisory id. The check runs inside each detector and drops only the owning package, so a sibling package's real finding still fires; a `blocker` is never suppressible. Suppressions print one line in the console banner and `.bkit/advisories.md`. Wired for `tagged-tests-no-ci-home` (the package holding the test file) and `test-integration-env-not-asserted` (the repo root — the only manifest that detector reads).
|
|
39
|
+
|
|
40
|
+
### Removed
|
|
41
|
+
|
|
42
|
+
- **GitHub Packages install-auth machinery** (#408). `BKIT_GH_TOKEN_INSTALL`, the four-surface token presence matrix, the `.npmrc` registry-mapping migration, and the CI / Vercel / cloud / Renovate install-auth steps are gone; the templates that wired them (`bkit-ci.yml`, `bkit-cloud.yml`, `bkit-renovate.yml`) no longer reference them. `BKIT_GH_TOKEN` (GitHub MCP + self-hosted Renovate platform auth) is unchanged.
|
|
43
|
+
|
|
44
|
+
---
|
|
45
|
+
|
|
9
46
|
## [5.0.0] — 2026-10-11
|
|
10
47
|
|
|
11
48
|
bkit owns only what a workflow step runs or parses (#489). Everything a person or another tool runs — the CI workflow, git hooks, lint and prose configs, editor and cloud-agent setup, dependency updaters, helper scripts — ships as a template the consumer copies and owns. Every file bkit ships is in one of three groups: an owned file, an owned block in a shared file, or a template, copied to `.bkit/templates/`.
|
package/README.md
CHANGED
|
@@ -1,11 +1,13 @@
|
|
|
1
1
|
<p align="center">
|
|
2
2
|
<picture>
|
|
3
3
|
<source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-hero-dark.svg">
|
|
4
|
-
<img alt="bkit — from vibe coding to production code. A senior engineering team's process, run by AI agents
|
|
4
|
+
<img alt="bkit — from vibe coding to production code. A senior engineering team's process, ready-made, run by AI agents and battle-tested over more than 1,000 commits." src=".github/assets/bkit-hero-light.svg" width="100%">
|
|
5
5
|
</picture>
|
|
6
6
|
</p>
|
|
7
7
|
|
|
8
8
|
<p align="center">
|
|
9
|
+
<a href="https://github.com/cbartens/bkit/actions/workflows/bkit-ci.yml"><img alt="CI" src="https://github.com/cbartens/bkit/actions/workflows/bkit-ci.yml/badge.svg?branch=main"></a>
|
|
10
|
+
<a href="https://www.npmjs.com/package/@cbartens/bkit"><img alt="npm version" src="https://img.shields.io/npm/v/@cbartens/bkit"></a>
|
|
9
11
|
<a href="#license"><img alt="License: PolyForm Noncommercial or PolyForm Small Business" src="https://img.shields.io/badge/license-PolyForm%20Noncommercial%20%2F%20Small%20Business-blue"></a>
|
|
10
12
|
<img alt="Node 20+" src="https://img.shields.io/badge/node-%E2%89%A520-339933">
|
|
11
13
|
<img alt="Works with Claude Code, Cursor, Codex and opencode" src="https://img.shields.io/badge/works%20with-Claude%20Code%20%C2%B7%20Cursor%20%C2%B7%20Codex%20%C2%B7%20opencode-8250df">
|
|
@@ -14,43 +16,64 @@
|
|
|
14
16
|
<p align="center">
|
|
15
17
|
<a href="#quick-start">Quick start</a> ·
|
|
16
18
|
<a href="#a-ready-made-workflow-for-every-job">Workflows</a> ·
|
|
17
|
-
<a href="#
|
|
19
|
+
<a href="#a-ci-pipeline-built-the-way-senior-teams-build-them">CI template</a> ·
|
|
20
|
+
<a href="#right-context-at-the-right-step">Context</a> ·
|
|
18
21
|
<a href="#faq">FAQ</a> ·
|
|
19
22
|
<a href=".bkit/install.md">Install guide</a>
|
|
20
23
|
</p>
|
|
21
24
|
|
|
22
|
-
AI coding agents are fast, but on their own they skip the parts that make software safe to ship: a design someone challenged, a plan someone checked, a second pair of eyes on every change, tests that actually ran.
|
|
25
|
+
AI coding agents are fast, but on their own they skip the parts that make software safe to ship: a design someone challenged, a plan someone checked, a second pair of eyes on every change, tests that actually ran. Vibe coding gets you a demo. Getting that demo to production takes a process.
|
|
23
26
|
|
|
24
|
-
**bkit
|
|
27
|
+
**bkit is that process, ready-made.** You describe a feature in a GitHub or Linear issue. AI agents design it, plan it, build it, review it with agents that didn't write it, fix what breaks, and ship it, with project docs and memory kept up to date along the way.
|
|
28
|
+
|
|
29
|
+
- **For solo founders and makers** who have outgrown vibe coding: you get the habits of a senior engineering team without hiring one. You need to be able to read a plan and make a call, not write the code.
|
|
30
|
+
- **For engineers** who want a proven agentic process instead of building their own: rules, prompts, workflows, guardrails, audits and a CI pipeline that already work together.
|
|
31
|
+
|
|
32
|
+
**Battle-tested, not a weekend prompt pack.** bkit is built with bkit. Its rules, prompts and workflows have been refined over >1,000 commits, >500 issues and >100 merged pull requests run through its own pipeline, and that history is recorded in >200 lessons and >300 decisions agents read before they start.
|
|
25
33
|
|
|
26
34
|
<p align="center">
|
|
27
35
|
<picture>
|
|
28
36
|
<source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-features-dark.svg">
|
|
29
|
-
<img alt="What ships with bkit:
|
|
37
|
+
<img alt="What ships with bkit, one coloured row per phase. Design: three rival designs, probe code for the risky unknowns, reads your history, reviewed for failure modes. Plan: five reviewers, big work split up, learns from past bugs and postponed work, more than 30 audits. Build: writes and verifies, hunts bugs and security holes, checks the plan is still current, skills on demand. Debug: outside evidence from CI and your platforms, root cause first, hard-bug mode, knows when to stop. Ship: honest CI, nothing quietly dropped, docs and memory, never touches main. Every phase: any AI tool, best model per job, independent review, laptop to cloud." src=".github/assets/bkit-features-light.svg" width="100%">
|
|
30
38
|
</picture>
|
|
31
39
|
</p>
|
|
32
40
|
|
|
41
|
+
## >200 files of best practice, ready to use
|
|
42
|
+
|
|
43
|
+
Everything a senior team would otherwise write down over years, in files you can read:
|
|
44
|
+
|
|
45
|
+
<!-- prettier-ignore -->
|
|
46
|
+
| What | How many | What it does for you |
|
|
47
|
+
| --- | --- | --- |
|
|
48
|
+
| Agents | >40 | Single-job specialists, each with its own model, thinking depth and tool list. A reviewer can read code but can't change it. |
|
|
49
|
+
| Workflows | 6 | The five phases plus a cloud router. Every step ends in a checklist and a mechanical check before the next one starts. |
|
|
50
|
+
| Agent rules | >70 | One shared rulebook every agent follows: read before editing, never defer silently, report honestly, never rewrite history. |
|
|
51
|
+
| Guardrails | >10 hook files | Block dangerous commands and make agents investigate before they edit, on all four AI tools. |
|
|
52
|
+
| Audits | >30 | Security, privacy, accessibility, performance, reliability, database, LLM usage, cost and more. Findings feed straight into a plan. |
|
|
53
|
+
| Project docs | 10 + index | Architecture, data schema, deployments, testing, security, monitoring, design system, tech stack, setup, and an index telling each agent what to read at each step. |
|
|
54
|
+
| Templates | >60 | A full CI pipeline, cloud agents, git hooks, linters, dependency updates, secrets sync, code search, and >10 ready-made connectors for your platforms. |
|
|
55
|
+
|
|
33
56
|
## A ready-made workflow for every job
|
|
34
57
|
|
|
35
|
-
One command per job. Each one runs a team of specialised agents,
|
|
58
|
+
One command per job. Each one runs a team of specialised agents, so you don't have to write prompts or remember steps.
|
|
36
59
|
|
|
37
60
|
<!-- prettier-ignore -->
|
|
38
61
|
| Job | Command | What happens |
|
|
39
62
|
| --- | --- | --- |
|
|
40
|
-
| Work out how to build it | `/bkit-design` |
|
|
41
|
-
| Plan the work | `/bkit-plan` | A step-by-step plan, stress-tested by five reviewers
|
|
42
|
-
| Build it | `/bkit-build` |
|
|
43
|
-
| Fix what broke | `/bkit-debug` |
|
|
44
|
-
| Ship it | `/bkit-ship` | Checks nothing was
|
|
45
|
-
| Health check |
|
|
46
|
-
| Housekeeping | utility agents | Keep docs, decisions, known
|
|
63
|
+
| Work out how to build it | `/bkit-design` | Reads related issues and past decisions, has three agents propose different approaches and two critique them, and writes throwaway code to test any risky unknowns the reviewers flag. You get one design to approve. |
|
|
64
|
+
| Plan the work | `/bkit-plan` | A step-by-step plan, stress-tested by five reviewers who also see past bugs and postponed work. Too big for one build? It's split into pieces. You approve it. |
|
|
65
|
+
| Build it | `/bkit-build` | Checks the plan still matches the code, writes it, verifies every task, hunts for bugs and security holes, adds edge-case tests, and opens a pull request. |
|
|
66
|
+
| Fix what broke | `/bkit-debug` | Pulls evidence from CI and your platforms, finds the root cause, fixes it, re-tests and records the lesson. Hard runtime bugs get their own mode; if it can't fix something, it stops and writes you a clear handover. |
|
|
67
|
+
| Ship it | `/bkit-ship` | Checks nothing planned was quietly dropped, waits for every test lane to pass, merges into `dev`, and updates the docs. |
|
|
68
|
+
| Health check | >30 audits | One specialist checklist per area. Findings feed straight into `/bkit-plan`. |
|
|
69
|
+
| Housekeeping | 7 utility agents | Keep docs, decisions, lessons and known bugs current, and rank what to work on next. |
|
|
47
70
|
|
|
48
71
|
## How it works
|
|
49
72
|
|
|
50
73
|
<p align="center">
|
|
51
74
|
<picture>
|
|
52
75
|
<source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-pipeline-dark.svg">
|
|
53
|
-
<img alt="The bkit pipeline: design, plan, build and ship, with debug fixing failed tests.
|
|
76
|
+
<img alt="The bkit pipeline: design, plan, build and ship, with debug fixing failed tests. Each dot is one of 40 AI agents: 10 in design, 10 in plan, 11 in build, 5 in debug and 4 in ship. It waits for your sign-off after design, after plan and before merge, merges into dev, and leaves production to you. Runs on Claude Code, Cursor, Codex and opencode." src=".github/assets/bkit-pipeline-light.svg" width="100%">
|
|
54
77
|
</picture>
|
|
55
78
|
</p>
|
|
56
79
|
|
|
@@ -59,37 +82,69 @@ One command per job. Each one runs a team of specialised agents, 48 in total, so
|
|
|
59
82
|
<p align="center">
|
|
60
83
|
<picture>
|
|
61
84
|
<source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-fences-dark.svg">
|
|
62
|
-
<img alt="You don't steer AI, you build fences. AI agents start out scattered at design and are funnelled through plan, build, debug and ship into production-grade code. At design and plan, reviewer agents fence the work in; from build onwards, automated checks (typecheck, lint, formatting, prose, tests) join them. Work that goes off target is sent back and retried, a failed test goes to debug, which finds the root cause, fixes it and re-runs the tests until they pass, and bkit waits for your sign-off after design, after plan and before merge." src=".github/assets/bkit-fences-light.svg" width="100%">
|
|
85
|
+
<img alt="You don't steer AI, you build fences. AI agents start out scattered at design and are funnelled through plan, build, debug and ship into production-grade code. At design and plan, reviewer agents fence the work in; from build onwards, automated checks from the CI template (typecheck, lint, formatting, prose, tests) join them. Work that goes off target is sent back and retried, a failed test goes to debug, which finds the root cause, fixes it and re-runs the tests until they pass, and bkit waits for your sign-off after design, after plan and before merge." src=".github/assets/bkit-fences-light.svg" width="100%">
|
|
63
86
|
</picture>
|
|
64
87
|
</p>
|
|
65
88
|
|
|
66
|
-
|
|
89
|
+
Rules and prompts only go so far: an agent can be talked into calling something done. Reviewer agents fence in the design and the plan. From the first line of code, automated checks join them, and those can't be argued with.
|
|
67
90
|
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
91
|
+
## A CI pipeline built the way senior teams build them
|
|
92
|
+
|
|
93
|
+
CI (continuous integration) is the robot that runs every check on every change, on GitHub's servers, before anything merges. It's the strongest fence there is, and most people who start with vibe coding have never set one up. bkit ships one ready to adopt, and its workflows are built around it:
|
|
94
|
+
|
|
95
|
+
- **Ready on day one.** Two lanes run side by side: quick checks (type checking, formatting, a prose checker, a scanner for junk code AI tends to write, a workflow-file checker, and `bkit check`) and unit tests.
|
|
96
|
+
- **A green tick means every test ran.** One final check joins all lanes and is the only one branch protection needs. It fails if any lane failed, was skipped or cancelled, or ran zero tests, so a half-finished run can't pass as tested.
|
|
97
|
+
- **Grows with your project.** >20 ready-to-enable building blocks: integration tests, end-to-end tests for web, iOS and Android, database migrations (locked once merged, with security-policy checks), coverage reports, waiting for preview deploys, live checks against the deployed site, smoke and health checks, and a planner that runs only what a change affects. `bkit check` reminds you of each one until you enable or delete it.
|
|
98
|
+
- **Safe by default.** Every third-party action is pinned to an exact commit, the downloaded prose checker is checksum-verified, and pull-request titles never reach a script unescaped.
|
|
99
|
+
- **Doesn't waste minutes.** A commit that already passed isn't re-tested, and a newer push cancels the older run, except on your production branch, where a deploy must never be cut off halfway.
|
|
100
|
+
- **Wired into the workflows.** `/bkit-ship` merges only when the final check is green, `/bkit-debug` reads its failed logs, the cloud router starts from its result, and the gates audit flags any check that can never fail.
|
|
101
|
+
|
|
102
|
+
## Right context at the right step
|
|
103
|
+
|
|
104
|
+
<p align="center">
|
|
105
|
+
<picture>
|
|
106
|
+
<source media="(prefers-color-scheme: dark)" srcset=".github/assets/bkit-context-dark.svg">
|
|
107
|
+
<img alt="What it knows: right context, right step, written back as it learns. In your repo, bkit reads project docs at every step and updates them at ship; reads and writes lessons, decisions, postponed work and known bugs; writes designs and plans that later steps read; reads audit reports at plan and a code map at every step; keeps run state and stats at every step; adds skills at build and removes them at ship. Outside your repo, it reads and updates the GitHub or Linear issue at every step, searches related issues at design, plan and debug, searches the web at design and debug, reads CI runs and test reports at debug and ship, reads runtime platforms such as Sentry, Vercel, Supabase and Stripe at debug, and opens, fixes and merges the pull request." src=".github/assets/bkit-context-light.svg" width="100%">
|
|
108
|
+
</picture>
|
|
109
|
+
</p>
|
|
110
|
+
|
|
111
|
+
Most AI tools forget everything when the chat ends. bkit keeps what it knows in plain files in your repo, and each step reads what it needs and writes back what it learned:
|
|
112
|
+
|
|
113
|
+
- **Documentation that keeps itself current.** Install sets up the docs a professional project keeps: architecture, data schema, deployments, testing, security, monitoring, design system, tech stack and local setup. Agents fill them in as they work, `/bkit-ship` brings them up to date after every feature, and an index tells each agent which docs to read at each step. The docs stay current because the agents depend on them.
|
|
114
|
+
- **Project memory agents actually read.** Four ledgers record lessons from every fix (`docs/knowledge.jsonl`), decisions and the reasons behind them (`docs/decisions.jsonl`), work consciously postponed (`docs/deferrals.jsonl`) and known bugs (`docs/failures.jsonl`). Planning reviewers see the past bugs and postponed work closest to the new feature, debug reads the lessons first, and `/bkit-ship` checks nothing postponed was quietly dropped.
|
|
115
|
+
- **Evidence from outside, when it's needed.** Design searches your backlog for related issues and checks the web for feasibility. Debug pulls failed CI logs, the diff since the last green run, end-to-end reports and runtime errors. >10 ready-made connectors cover GitHub, Sentry, Vercel, Supabase, Stripe, Expo, Playwright, Maestro, Inngest, Resend, Cloud Run, Tavily web search and Serena, each easy to customise, extend or leave out. A connector that isn't set up is reported as such, never read as "all clear".
|
|
116
|
+
- **Progress lives in your repo, not a chat window.** Run state is saved after every step, so a crashed run resumes where it stopped, on any tool.
|
|
117
|
+
|
|
118
|
+
## What else you get
|
|
71
119
|
|
|
72
120
|
### The quality is real
|
|
73
121
|
|
|
74
122
|
- **Everything is checked by an agent that didn't write it.** An AI checking its own work tends to approve it. bkit gives every design, plan and code change to separate reviewers, each with one job (one hunts bugs, another security holes). They never see each other's verdicts, and several review groups mix models on purpose, so one model's blind spot is less likely to get past all of them.
|
|
75
|
-
- **
|
|
76
|
-
- **
|
|
123
|
+
- **"Done" is checked by code, not taken on trust.** Every step's output is verified before the next step starts, a task is ticked only when its result really exists, and a silent TODO or skipped test blocks the merge.
|
|
124
|
+
- **Broken builds fix themselves, and stay fixed.** `/bkit-debug` finds the root cause before it changes anything, fixes it, re-runs the tests and records the lesson. Bugs that only show up at runtime get a dedicated mode that adds logging, fixes on evidence and removes the logging again.
|
|
125
|
+
- **It knows when to stop.** If a failure can't be fixed, bkit writes a clear handover and stops, instead of guessing over and over.
|
|
126
|
+
|
|
127
|
+
### Engineering know-how, built in
|
|
128
|
+
|
|
129
|
+
- **Best model for each job, on every tool.** Each agent has its own model and thinking depth, chosen per tool and provider. Deep reasoning models do architecture and security review; quick ones write summaries. Starting a session on a cheaper model never quietly downgrades the reviewers.
|
|
130
|
+
- **It tests ideas before you commit to them.** When reviewers flag an unknown a design depends on, design writes throwaway probe code to settle it before you approve, and a design reviewer checks failure modes and monitoring, not just whether it can be built.
|
|
131
|
+
- **Big features are split up.** A plan too big for one build becomes a sequence of smaller plans, and each is re-checked against the current code right before it's built.
|
|
132
|
+
- **Numbers on your own work.** Every run records its time, size of change and retries in `.bkit/stats.jsonl`, and posts them to the issue next to the median of your last five runs.
|
|
133
|
+
- **Health checks on demand.** >30 audit checklists act like hiring a specialist for a day.
|
|
77
134
|
|
|
78
135
|
### It fits how you work
|
|
79
136
|
|
|
80
|
-
- **Never blocked by usage limits.** Out of Claude for the week? Carry on in Cursor, Codex or opencode, or on free models on your own machine through Ollama. Same feature, same checks, nothing to set up again
|
|
81
|
-
- **Start on your laptop, check in from your phone.** A feature started at your desk can continue in a cloud session (Claude Code on the web or the Claude app, Cursor cloud agents), or start by itself when CI finishes: ship on green, debug on red. The cloud setup ships ready to adopt.
|
|
137
|
+
- **Never blocked by usage limits.** Out of Claude for the week? Carry on in Cursor, Codex or opencode, or on free models on your own machine through Ollama. Same feature, same checks, nothing to set up again.
|
|
138
|
+
- **Start on your laptop, check in from your phone.** A feature started at your desk can continue in a cloud session (Claude Code on the web or the Claude app, Cursor cloud agents, or opencode on GitHub Actions), or start by itself when CI finishes: ship on green, debug on red. The cloud setup ships ready to adopt.
|
|
82
139
|
- **Run several features at once.** Each one works in its own copy of the repo (a git worktree), so they never trip over each other.
|
|
83
140
|
- **Your issue tracker is the control panel.** bkit reads the GitHub or Linear issue, posts progress as it goes, moves the issue along and links the pull request.
|
|
84
141
|
- **The right expertise for each feature.** When a plan needs, say, Stripe or Supabase, bkit installs a matching skill for the build and removes it when the feature ships.
|
|
85
142
|
|
|
86
|
-
###
|
|
143
|
+
### You stay in control
|
|
87
144
|
|
|
88
|
-
- **
|
|
89
|
-
- **
|
|
90
|
-
- **
|
|
91
|
-
- **Numbers on your own work.** Every run records its time, size of change and retries in `.bkit/stats.jsonl`, and posts them to the issue next to the median of your last five runs.
|
|
92
|
-
- **Health checks on demand.** 35 audit checklists act like hiring a specialist for a day: security, privacy, accessibility, architecture, performance, database, LLM usage, cost and more.
|
|
145
|
+
- **Decide in plain English, not code.** Before any code is written you approve two short documents: a design ("three ways to build this; we recommend this one, because…") and a plan ("these twelve steps, and how we'll know each is done").
|
|
146
|
+
- **Three sign-offs, and production stays yours.** bkit stops after the design, after the plan and before merging. It merges into your `dev` branch and never touches `main`: promoting to production is always your call. Cloud mode can ship on green without you, but only for issues you've labelled `bkit:auto`, and removing the label stops it.
|
|
147
|
+
- **Guardrails on the AI itself.** Dangerous commands like force-pushing or rewriting history are blocked. Each agent only gets the tools its job needs.
|
|
93
148
|
|
|
94
149
|
## Templates ready to adopt
|
|
95
150
|
|
|
@@ -98,8 +153,9 @@ bkit installs only what its workflows run. Everything else, the things you or an
|
|
|
98
153
|
<!-- prettier-ignore -->
|
|
99
154
|
| Template | What it gives you |
|
|
100
155
|
| --- | --- |
|
|
101
|
-
| **CI pipeline** |
|
|
156
|
+
| **CI pipeline** | Two lanes ready to go and >20 building blocks for the rest ([above](#a-ci-pipeline-built-the-way-senior-teams-build-them)). One final check is the only one branch protection needs. |
|
|
102
157
|
| **Quality checks** | Type checking, formatting, a prose checker, a scanner for junk code AI tends to write, and a workflow-file checker, wired into git hooks and CI. Your `bkit:gate:*` scripts in `package.json` define what "the checks" are, and the gates audit flags any check that can never fail. |
|
|
158
|
+
| **Context connectors** | >10 ready-made connectors that let `/bkit-debug` read CI, error trackers, hosting, databases, payments, email, queues and the web. |
|
|
103
159
|
| **Cloud agents** | When CI finishes, a cloud agent picks up: ship on green, debug on red. No laptop needed. |
|
|
104
160
|
| **Dependency updates** | Ready-made Renovate or Dependabot setups: grouped minor updates, pinned GitHub Actions, and security fixes that skip the weekly queue. |
|
|
105
161
|
| **Secrets sync** | One local file holds every key. One command pushes them to Vercel, GitHub Actions, Google Cloud, Supabase and Expo; another proves every copy matches without printing a value. |
|
|
@@ -112,11 +168,9 @@ You need a GitHub repo, Node 20+, pnpm, and at least one of Claude Code, Cursor,
|
|
|
112
168
|
|
|
113
169
|
**Easiest:** copy the [install prompt](.bkit/install.md#install--first-time) into your AI coding tool and let it do the setup.
|
|
114
170
|
|
|
115
|
-
**By hand:**
|
|
171
|
+
**By hand:** no token or registry setup — bkit is public on npmjs and installs like any other package.
|
|
116
172
|
|
|
117
173
|
```bash
|
|
118
|
-
echo "@cbartens:registry=https://npm.pkg.github.com" >> .npmrc
|
|
119
|
-
pnpm config set "//npm.pkg.github.com/:_authToken=<your-token>"
|
|
120
174
|
pnpm add -D @cbartens/bkit
|
|
121
175
|
pnpm bkit install --claude # pick your tools: --claude --cursor --codex --opencode=<provider>
|
|
122
176
|
```
|
|
@@ -127,18 +181,21 @@ Adopt the templates you want from `.bkit/templates/`, then open an issue and run
|
|
|
127
181
|
/bkit-design ISSUE-123
|
|
128
182
|
```
|
|
129
183
|
|
|
130
|
-
Full install, upgrade and CI
|
|
184
|
+
Full install, upgrade and CI setup: [`.bkit/install.md`](.bkit/install.md).
|
|
131
185
|
|
|
132
186
|
## FAQ
|
|
133
187
|
|
|
134
188
|
**Do I need to know how to code?**
|
|
135
189
|
No, but you do need to read a design and a plan and decide whether they're right. Setup takes a few terminal commands, or one pasted prompt.
|
|
136
190
|
|
|
191
|
+
**Who is it not for?**
|
|
192
|
+
bkit is heavier than a single prompt. For a one-off script or a quick experiment, just ask your AI. bkit pays off on a project you'll keep changing and want to trust.
|
|
193
|
+
|
|
137
194
|
**What does it cost?**
|
|
138
195
|
bkit is free for personal use, non-profits and small businesses (fewer than 100 people and under US$1M revenue); larger companies need a commercial licence ([License](#license)). It runs on AI subscriptions you already have (Claude, Cursor, ChatGPT for Codex), on pay-as-you-go providers through opencode, or on free local models. Several agents reviewing in parallel uses more of your quota than a single chat; that's the price of the second opinions.
|
|
139
196
|
|
|
140
197
|
**Can it break my live site?**
|
|
141
|
-
Not without your sign-off. Work happens in a separate copy of the repo, goes through a pull request, must pass every test, and merges
|
|
198
|
+
Not without your sign-off. Work happens in a separate copy of the repo, goes through a pull request, must pass every test, and merges into `dev`, never `main`.
|
|
142
199
|
|
|
143
200
|
**Which issue tracker?**
|
|
144
201
|
GitHub Issues or Linear.
|
|
@@ -148,11 +205,12 @@ GitHub Issues or Linear.
|
|
|
148
205
|
|
|
149
206
|
- **Isolation.** Every run gets its own git worktree; a per-feature lock blocks duplicate runs of the same feature, and a short repo-wide lock serialises only the moments that write to `dev`.
|
|
150
207
|
- **Resume from state, not session.** Run state lives in `status.jsonl` and `docs/plans/`. A crashed or interrupted run resumes from its last completed step, on any host.
|
|
151
|
-
- **
|
|
208
|
+
- **Mechanical step gates.** `bkit steps finish` checks each step's verdict and artifacts before the workflow moves on; build ticks a task only on a confirmed artifact; ship's deferred sweep fails the merge on an unplanned gap.
|
|
209
|
+
- **Engine.** The `bkit` CLI is TypeScript in [`.bkit/core/engine/`](.bkit/core/engine/), built to `dist/`, covered by >3,000 tests. `commands/` holds what you type; `install/`, `render/`, `checks/`, `ledgers/` and `shared/` hold the code underneath; `audits/` holds the tests that read shipped text.
|
|
152
210
|
- **One source, every host.** `.bkit/` renders `.claude/`, `.cursor/`, `.codex/` and `.opencode/`. `bkit check` is the CI drift gate.
|
|
153
211
|
- **Reviewer independence.** Parallel reviewers can't read sibling output. Design brainstorm, design review and plan scope-check groups also cross models (Opus + Sonnet on Claude; Grok + Composer on Cursor); depth-sensitive lenses (plan review, build challenge) stay on the top tier.
|
|
154
212
|
- **Per-agent pins.** Model and effort per agent, per provider ([`.bkit/prompts.md`](.bkit/prompts.md) § Models), immune to the session default.
|
|
155
|
-
- **Against the literature.** bkit fully implements
|
|
213
|
+
- **Against the literature.** bkit fully implements 13 of the 22 patterns in Antonio Gulli's _Agentic Design Patterns_, partly implements 7 (scoped to shipping code), leaves 2 out by design, and goes beyond the book in 8 places. Full mapping and every agent in execution order: [`.bkit/comparison.md`](.bkit/comparison.md).
|
|
156
214
|
|
|
157
215
|
</details>
|
|
158
216
|
|
|
@@ -161,7 +219,7 @@ GitHub Issues or Linear.
|
|
|
161
219
|
<!-- prettier-ignore -->
|
|
162
220
|
| Read | For |
|
|
163
221
|
| --- | --- |
|
|
164
|
-
| [`.bkit/install.md`](.bkit/install.md) | Install, upgrade,
|
|
222
|
+
| [`.bkit/install.md`](.bkit/install.md) | Install, upgrade, CI auth, uninstall, recovery |
|
|
165
223
|
| [`.bkit/README.md`](.bkit/README.md) | Day-to-day use: running workflows, environment, tracker setup, CLI |
|
|
166
224
|
| [`.bkit/workflows.md`](.bkit/workflows.md) | Every workflow step, verdict and contract |
|
|
167
225
|
| [`.bkit/providers.md`](.bkit/providers.md) | Tool and provider differences, model pins |
|