codebyplan 1.13.64 → 1.13.66

package/dist/lib/lsp-detect.d.ts

@@ -0,0 +1,42 @@
+/**
+ * LSP plugin detection and mapping for `codebyplan lsp`.
+ *
+ * Plugin names are the Claude Code `<lang>-lsp` identifiers discovered by
+ * reading the Claude Code settings documentation and the project's .claude/
+ * skills/cbp-build-cc-settings/reference/settings-fields.md (enabledPlugins
+ * format: `{"plugin@marketplace": true/false}`). These names were
+ * research-verified as of 2026-06 — to correct or extend the list, update
+ * LSP_TABLE below; the key `plugin` field is the Claude Code plugin registry
+ * name and the `binary` field is the executable `which` checks for.
+ */
+export interface LspServer {
+    language: string;
+    plugin: string;
+    binary: string;
+    npmPackage: string | null;
+    installHint: string;
+}
+/**
+ * Static LSP table — 11 entries covering the most common languages.
+ * Marketplace: claude-plugins-official (auto-available, no extraKnownMarketplaces needed).
+ * Key format in settings.json: `${plugin}@claude-plugins-official`
+ */
+export declare const LSP_TABLE: LspServer[];
+/**
+ * Map an array of detected tech-stack names (as emitted by detectTechStack)
+ * to the corresponding LSP server entries from LSP_TABLE.
+ *
+ * - Matching is case-insensitive.
+ * - Result is deduped by `plugin` field — multiple detectedNames that map to
+ *   the same plugin (e.g. "TypeScript" + "Next.js" both → typescript-lsp)
+ *   produce a single entry.
+ * - Unknown names (not in ALIAS_MAP) are silently ignored.
+ */
+export declare function mapTechStackToLsp(detectedNames: string[]): LspServer[];
+/**
+ * Check whether a binary is available on the system PATH using `which`.
+ * Returns true if found (exit status 0), false for any other outcome
+ * (not found, spawnSync error, etc.). Never throws.
+ */
+export declare function binaryOnPath(binary: string): boolean;
+//# sourceMappingURL=lsp-detect.d.ts.map

package/dist/lib/lsp-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-detect.d.ts","sourceRoot":"","sources":["../../src/lib/lsp-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,SAAS,EAkFhC,CAAC;AAoDF;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAiBtE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAIpD"}

package/dist/lib/manifest.d.ts

@@ -0,0 +1,88 @@
+export interface ManifestEntry {
+    /** POSIX-relative source path inside the package's templates dir. */
+    src: string;
+    /** POSIX-relative destination path inside the project's `.claude/`. */
+    dest: string;
+    /** sha256 of the file as it was written at install / update time. */
+    hash: string;
+}
+export interface Manifest {
+    /** Version of codebyplan that produced this manifest. */
+    version: string;
+    /** ISO timestamp of the most recent install/update. */
+    installed_at: string;
+    /** Every file currently considered owned by codebyplan. */
+    files: ManifestEntry[];
+}
+/** Current manifest filename (post-CHK-132 merge — canonical for the merged codebyplan package). */
+export declare const NEW_MANIFEST_FILENAME = ".cbp.manifest.json";
+/** Mid-gen manifest filename (post-CHK-113 cbp- prefix migration, pre-CHK-132). */
+export declare const MID_MANIFEST_FILENAME = ".cbp-claude.manifest.json";
+/** Legacy manifest filename (pre-CHK-113). Kept for backward-compat reads + uninstall cleanup. */
+export declare const OLD_MANIFEST_FILENAME = ".codebyplan-claude.manifest.json";
+/** Manifest location is fixed under `.claude/` so uninstall can locate it. */
+export declare function manifestPath(projectDir: string): string;
+/** Mid-gen manifest location — used by readManifest fallback + uninstall cleanup. */
+export declare function midManifestPath(projectDir: string): string;
+/** Legacy manifest location — used by readManifest fallback + uninstall cleanup. */
+export declare function oldManifestPath(projectDir: string): string;
+/**
+ * Read the manifest from disk. Returns `null` when no manifest file exists
+ * (i.e. codebyplan has never been installed in this project).
+ *
+ * Three-tier read: prefers the current filename; falls back to the mid-gen
+ * filename (.cbp-claude.manifest.json from CHK-113); then falls back to the
+ * legacy filename (.codebyplan-claude.manifest.json pre-CHK-113). The next
+ * `writeManifest` call always writes to the new canonical path — running
+ * `install` or `update` against a legacy install effectively completes the
+ * migration on first invocation.
+ *
+ * A corrupt manifest throws — it is an exceptional state and refusing to
+ * proceed is safer than silently treating it as "no install" (which would
+ * happily overwrite user files).
+ */
+export declare function readManifest(projectDir: string): Manifest | null;
+export declare function writeManifest(projectDir: string, manifest: Manifest): void;
+export declare function defaultManifest(): Manifest;
+/**
+ * User-scope manifest location — defaults to `~/.claude/.cbp.manifest.json`.
+ * Pass `userDir` to target a different directory (used by tests to redirect
+ * away from the real home directory).
+ */
+export declare function userManifestPath(userDir?: string): string;
+/**
+ * User-scope mid-gen manifest location — for migration fallback.
+ */
+export declare function userMidManifestPath(userDir?: string): string;
+/**
+ * User-scope legacy manifest location — for migration fallback.
+ */
+export declare function userOldManifestPath(userDir?: string): string;
+/**
+ * Return the manifest path for the given scope.
+ * - `'user'` → `<userDir ?? ~/.claude>/.cbp.manifest.json`
+ * - `'project'` → `<projectDir>/.claude/.cbp.manifest.json`
+ */
+export declare function manifestPathForScope(scope: "user" | "project", projectDir: string, userDir?: string): string;
+/**
+ * Read the manifest for the given scope. Returns `null` when no manifest
+ * file exists (i.e. the package has never been installed at that scope).
+ *
+ * Three-tier fallback applies to both scopes.
+ *
+ * Overloaded so callers don't pass a meaningless `projectDir` when scope === 'user':
+ *   readManifestForScope('user', userDir?)
+ *   readManifestForScope('project', projectDir)
+ */
+export declare function readManifestForScope(scope: "user", userDir?: string): Manifest | null;
+export declare function readManifestForScope(scope: "project", projectDir: string): Manifest | null;
+/**
+ * Write the manifest for the given scope.
+ *
+ * Overloaded so callers don't pass a meaningless `projectDir` when scope === 'user':
+ *   writeManifestForScope('user', manifest, userDir?)
+ *   writeManifestForScope('project', manifest, projectDir)
+ */
+export declare function writeManifestForScope(scope: "user", manifest: Manifest, userDir?: string): void;
+export declare function writeManifestForScope(scope: "project", manifest: Manifest, projectDir: string): void;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/lib/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/lib/manifest.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACvB,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,YAAY,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAED,oGAAoG;AACpG,eAAO,MAAM,qBAAqB,uBAAuB,CAAC;AAE1D,mFAAmF;AACnF,eAAO,MAAM,qBAAqB,8BAA8B,CAAC;AAEjE,kGAAkG;AAClG,eAAO,MAAM,qBAAqB,qCAAqC,CAAC;AAExE,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,qFAAqF;AACrF,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAiBhE;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAgB1E;AAED,wBAAgB,eAAe,IAAI,QAAQ,CAM1C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,CAIR;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,GACf,QAAQ,GAAG,IAAI,CAAC;AACnB,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,GACjB,QAAQ,GAAG,IAAI,CAAC;AA6BnB;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAAC;AACR,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,GACjB,IAAI,CAAC"}

package/dist/lib/mcp-client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Minimal MCP JSON-RPC client for the standalone MCP server (mcp.codebyplan.com).
+ *
+ * Auth: Bearer JWT only. The standalone MCP host validates an OAuth access
+ * token (Authorization: Bearer ...) and rejects x-api-key with 401. The token
+ * is sourced from getAccessToken() (auto-refreshing); a not-logged-in caller
+ * gets a clear "run codebyplan login" error rather than a doomed request.
+ *
+ * Host: resolved via mcpEndpoint() (oauth/urls.ts) — the single source of
+ * truth for the CLI MCP base URL, shared with api.ts callMcpTool.
+ *
+ * Why this exists separately from api.ts callMcpTool:
+ *   Several round/task endpoints are not implemented as REST routes in
+ *   apps/web (no /api/rounds/[id] folder at all; /api/tasks/[id] exports
+ *   GET+PUT+DELETE but no PATCH). The MCP server exposes the underlying
+ *   tools (get_rounds, get_current_task, update_round, update_task) and is
+ *   the canonical write path. Unlike callMcpTool (a thin fire-and-forget
+ *   returning raw json.result), this client does full JSON-RPC envelope +
+ *   SSE-frame parsing and returns the typed content payload — which the
+ *   round write path depends on.
+ *
+ * Response shape:
+ *   { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: "<JSON>" }] } }
+ *
+ * Tool-level errors surface as result.isError=true with an "Error: ..."
+ * text payload; protocol-level errors surface as JSON-RPC error objects.
+ */
+export declare class McpError extends Error {
+    status?: number;
+    code?: string;
+    constructor(message: string, status?: number, code?: string);
+}
+/**
+ * Invoke an MCP tool by name. Returns the parsed JSON payload from
+ * result.content[0].text as T. Throws McpError on transport, protocol,
+ * or tool-level errors.
+ */
+export declare function mcpCall<T>(toolName: string, args: Record<string, unknown>): Promise<T>;
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/lib/mcp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.d.ts","sourceRoot":"","sources":["../../src/lib/mcp-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAOH,qBAAa,QAAS,SAAQ,KAAK;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;gBAEF,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM;CAM5D;AAcD;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAC7B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,CAAC,CAAC,CA2FZ"}

package/dist/lib/migrate-branch-model.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure library: branch-model migration from 3-branch to 2-tier model.
+ *
+ * Rewrites branch_config in .codebyplan/git.json (or legacy .codebyplan.json)
+ * from { integration: "development", staging: null, protected: ["main","development"], production: "main" }
+ * to   { integration: null, staging: null, protected: ["main"], production: "main" }
+ *
+ * Idempotent — second run is a no-op. NEVER deletes remote branches.
+ */
+export type BranchConfigShape = {
+    integration: string | null;
+    staging: string | null;
+    protected: string[];
+    production: string;
+};
+export type BranchMigrateResult = {
+    was_dirty: boolean;
+    before: BranchConfigShape | null;
+    after: BranchConfigShape;
+    config_path: string;
+    warnings: string[];
+    unmerged_check?: {
+        integration_branch: string | null;
+        unmerged_commits: number | null;
+        note: string;
+    };
+};
+export type RunBranchMigrationOptions = {
+    cwd?: string;
+    dryRun?: boolean;
+    skipFetch?: boolean;
+};
+export declare function runBranchMigration(opts?: RunBranchMigrationOptions): Promise<BranchMigrateResult>;
+//# sourceMappingURL=migrate-branch-model.d.ts.map

package/dist/lib/migrate-branch-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-branch-model.d.ts","sourceRoot":"","sources":["../../src/lib/migrate-branch-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAWH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACjC,KAAK,EAAE,iBAAiB,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,CAAC,EAAE;QACf,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;QAClC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;QAChC,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AA8HF,wBAAsB,kBAAkB,CACtC,IAAI,CAAC,EAAE,yBAAyB,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CAsI9B"}

package/dist/lib/migrate-local-config.d.ts

@@ -0,0 +1,39 @@
+export interface MigrationResult {
+    /** Operation completed (always true on a non-throwing return). */
+    migrated: true;
+    /**
+     * True iff actual layout files were written (i.e. a genuine migration
+     * occurred). False means the call was a structural no-op (already on new
+     * layout).
+     */
+    was_dirty: boolean;
+    /**
+     * Files actually written to or deleted from disk during migration.
+     */
+    files_changed: string[];
+    summary: string;
+}
+/**
+ * Returns `true` iff `.codebyplan.json` exists at `projectPath` AND
+ * `.codebyplan/repo.json` does NOT exist at `projectPath`.
+ *
+ * Any I/O error → `false` (best-effort detection, quiet by design).
+ */
+export declare function needsLocalMigration(projectPath: string): Promise<boolean>;
+/**
+ * Migrates the legacy `.codebyplan.json` + `.codebyplan.local.json` layout
+ * to the new `.codebyplan/` directory layout.
+ *
+ * Behavior tree (in order):
+ * 1. Collision check: if `.codebyplan` exists and is NOT a directory, throw.
+ * 2. Fresh new-layout guard: if `.codebyplan/repo.json` exists, return early.
+ * 3. Legacy file required: if `.codebyplan.json` absent, return early.
+ * 4. Parse legacy JSON.
+ * 5. mkdir `.codebyplan/` (recursive).
+ * 6. Partition legacy data into per-concern files.
+ * 7. Rewrite root `.gitignore` (replace legacy entry).
+ * 8. Delete legacy files.
+ * 9. Idempotency: step 2 handles re-invocation.
+ */
+export declare function runLocalMigration(projectPath: string): Promise<MigrationResult>;
+//# sourceMappingURL=migrate-local-config.d.ts.map

package/dist/lib/migrate-local-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-local-config.d.ts","sourceRoot":"","sources":["../../src/lib/migrate-local-config.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,QAAQ,EAAE,IAAI,CAAC;IACf;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAuCD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC,CAclB;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CAkO1B"}

package/dist/lib/migration-collisions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Migration timestamp collision detection.
+ *
+ * Replicates cbp-merge-main Step 1.5 comm logic — pure functions so the
+ * behaviour is testable without real git or filesystem calls.
+ *
+ * A "collision" is a numeric prefix that appears in the unique-to-ours set AND
+ * the unique-to-theirs set with different basenames. A shared filename (same
+ * prefix, same basename) is NOT a collision — it was already merged.
+ *
+ * Prefix extraction mirrors the skill's `sed 's|_.*||'` semantics:
+ *   prefix = everything before the first underscore in the basename (without .sql).
+ *   e.g. "20260101000000_add_users.sql"   → prefix "20260101000000"
+ *        "20260101000000_01_add_users.sql" → prefix "20260101000000"
+ *        (the _01_ is treated as part of the name, not a separate prefix segment)
+ */
+import type { RunFn } from "./supabase.js";
+export interface MigrationCollision {
+    /** The shared numeric prefix (everything before the first underscore). */
+    prefix: string;
+    /** Basenames (without .sql) on our side with this prefix. */
+    ours: string[];
+    /** Basenames (without .sql) on their side with this prefix. */
+    theirs: string[];
+}
+export interface ComputeMigrationCollisionsInput {
+    ourNames: string[];
+    theirNames: string[];
+}
+export interface ComputeMigrationCollisionsResult {
+    collisions: MigrationCollision[];
+}
+export interface ReadMigrationNamesOpts {
+    /** Production/base branch to compare against (e.g. "main"). */
+    base: string;
+    /** Working directory for git commands. */
+    cwd?: string;
+    /** Injectable git runner — returns stdout (throws on non-zero). */
+    run?: RunFn;
+}
+export interface MigrationNames {
+    ourNames: string[];
+    theirNames: string[];
+}
+/**
+ * Given the migration basenames on both sides of a would-be merge, return the
+ * set of true collisions: same numeric prefix, different basename.
+ *
+ * Pure function — no I/O.
+ */
+export declare function computeMigrationCollisions(input: ComputeMigrationCollisionsInput): ComputeMigrationCollisionsResult;
+/**
+ * Read migration filenames from both sides of a would-be merge.
+ *
+ * HEAD side (ours): `git ls-files supabase/migrations/` — includes staged renames.
+ * Base side (theirs): `git ls-tree -r --name-only origin/<base> supabase/migrations/`
+ *
+ * Returns basename arrays (not full paths), sorted.
+ */
+export declare function readMigrationNames(opts: ReadMigrationNamesOpts): MigrationNames;
+//# sourceMappingURL=migration-collisions.d.ts.map

package/dist/lib/migration-collisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-collisions.d.ts","sourceRoot":"","sources":["../../src/lib/migration-collisions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAM3C,MAAM,WAAW,kBAAkB;IACjC,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,+DAA+D;IAC/D,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,gCAAgC;IAC/C,UAAU,EAAE,kBAAkB,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,sBAAsB;IACrC,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,GAAG,CAAC,EAAE,KAAK,CAAC;CACb;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAkDD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,+BAA+B,GACrC,gCAAgC,CA8ClC;AAMD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,sBAAsB,GAC3B,cAAc,CAyChB"}

package/dist/lib/port-verify.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Port verification utilities.
+ *
+ * Pure functions that compare local package.json port references against
+ * DB port allocations. No API calls — callers provide allocations.
+ */
+import type { PortAllocation } from "./types.js";
+export interface PortMismatch {
+    /** Relative path to the package.json */
+    packageJsonPath: string;
+    /** Port found in the scripts */
+    scriptPort: number;
+    /** The matching allocation (if any) */
+    allocation: PortAllocation | null;
+    /** Description of the mismatch */
+    reason: string;
+}
+export interface UnallocatedApp {
+    /** App name (e.g., "web", "mcp") */
+    name: string;
+    /** Relative path (e.g., "apps/web") */
+    path: string;
+    /** Detected framework */
+    framework: string;
+    /** Port found in scripts (null if none) */
+    detectedPort: number | null;
+    /** Suggested dev command */
+    command: string;
+}
+/**
+ * Scan all package.json files for hardcoded port references and compare
+ * against DB allocations. Returns mismatches where a script port does not
+ * match any allocation.
+ */
+export declare function verifyPorts(projectPath: string, portAllocations: PortAllocation[]): Promise<PortMismatch[]>;
+/**
+ * Decide whether `pkg.scripts.dev` represents an actual long-running dev server.
+ *
+ * Returns `true` when the script invokes a known dev-server bin (Next.js, NestJS,
+ * Vite, Nuxt, SvelteKit, Expo) OR carries `--port` / `-p` as exact whitespace-
+ * delimited tokens (not substring match). Returns `false` for `tauri dev` (Tauri
+ * webview owns no port), `tsc --watch`, esbuild watchers, or absent/empty scripts.
+ *
+ * Exported for unit testing — module-internal use otherwise.
+ */
+export declare function isDevServerScript(pkg: Record<string, unknown>): boolean;
+/**
+ * Decide whether a port-allocation `label` corresponds to monorepo app `appName`.
+ *
+ * Normalisation: lowercase, replace `-` with whitespace, strip parentheses, then
+ * tokenise by whitespace. Returns `true` when the normalised `appName` appears as
+ * a complete token in the label's token list (not a substring).
+ *
+ * Examples:
+ *   ("Web Dev", "web") → true
+ *   ("Web Dev (codebyplan-vsextension)", "web") → true (parens stripped)
+ *   ("Webhooks Dev", "web") → false (token rejection)
+ *
+ * Exported for unit testing — module-internal use otherwise.
+ */
+export declare function labelMatchesAppName(label: string, appName: string): boolean;
+/**
+ * Find monorepo apps that don't have a port allocation.
+ * Uses discoverMonorepoApps from tech-detect and detectFramework from server-detect.
+ *
+ * An app is flagged as "unallocated" only when (a) no `port_allocations[]` label
+ * matches the app name (per `labelMatchesAppName`) AND (b) the package's `dev`
+ * script represents a real dev server (per `isDevServerScript`). Apps without a
+ * `dev` script, with non-server `dev` scripts (e.g. `tauri dev`, `tsc --watch`),
+ * or with malformed package.json are silently skipped.
+ */
+export declare function findUnallocatedApps(projectPath: string, portAllocations: PortAllocation[]): Promise<UnallocatedApp[]>;
+//# sourceMappingURL=port-verify.d.ts.map

package/dist/lib/port-verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port-verify.d.ts","sourceRoot":"","sources":["../../src/lib/port-verify.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,WAAW,YAAY;IAC3B,wCAAwC;IACxC,eAAe,EAAE,MAAM,CAAC;IACxB,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,UAAU,EAAE,cAAc,GAAG,IAAI,CAAC;IAClC,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,cAAc,EAAE,GAChC,OAAO,CAAC,YAAY,EAAE,CAAC,CAiCzB;AAaD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAmBvE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAsB3E;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,cAAc,EAAE,GAChC,OAAO,CAAC,cAAc,EAAE,CAAC,CA8C3B"}

package/dist/lib/prompt.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Structured-signal answers for the three prompt shapes.
+ *
+ * Returning typed enums (not raw label strings) so call sites branch on a
+ * controlled set; the user-facing label can change without breaking
+ * downstream code.
+ */
+export type OverwriteAnswer = "overwrite" | "skip" | "diff";
+export type OptInAnswer = "opt-in" | "skip";
+export type RemoveAnswer = "remove" | "keep";
+export interface PromptOpts {
+    /** Short-circuit every prompt to its recommended default. */
+    yes: boolean;
+}
+/**
+ * Prompt for what to do with a file that's been hand-modified by the user
+ * since install (on-disk hash differs from manifest hash). Default under
+ * `--yes` is `overwrite` (replace with the new packaged version).
+ */
+export declare function promptOverwrite(filePath: string, opts: PromptOpts, showDiff?: () => void): Promise<OverwriteAnswer>;
+/**
+ * Prompt for whether to install a NEW file (present in the package's
+ * templates but not in the user's manifest — typically appearing in an
+ * `update` run after a package version added new content). Default under
+ * `--yes` is `opt-in`.
+ */
+export declare function promptOptIn(filePath: string, opts: PromptOpts): Promise<OptInAnswer>;
+/**
+ * Prompt for whether to remove a file the user previously installed that
+ * has since been DROPPED from the package's templates (typically appears
+ * in an `update` run after a package version removed content). Default
+ * under `--yes` is `remove`.
+ */
+export declare function promptRemove(filePath: string, opts: PromptOpts): Promise<RemoveAnswer>;
+/**
+ * Simple line-by-line unified-diff renderer. No external dep — the goal is
+ * to give the user enough signal to choose overwrite vs skip, not produce
+ * a perfect minimal diff.
+ */
+export declare function renderDiff(oldContent: string, newContent: string): string;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/lib/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/lib/prompt.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAC5D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAC5C,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,UAAU;IACzB,6DAA6D;IAC7D,GAAG,EAAE,OAAO,CAAC;CACd;AAgFD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,QAAQ,CAAC,EAAE,MAAM,IAAI,GACpB,OAAO,CAAC,eAAe,CAAC,CAc1B;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,WAAW,CAAC,CAYtB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,YAAY,CAAC,CAYvB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAiBzE"}

package/dist/lib/readme-generator.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Pure, side-effect-free library for generating and managing README.md files.
+ *
+ * Uses marker-bounded managed sections:
+ *   <!-- codebyplan:managed:start:<section> -->
+ *   ...content...
+ *   <!-- codebyplan:managed:end:<section> -->
+ *
+ * A drift hash is embedded inside the managed block:
+ *   <!-- codebyplan:hash:<sha256> -->
+ *
+ * DETERMINISTIC: no I/O, no Date.now/random, sorted output everywhere.
+ * Two calls with identical config produce byte-identical output.
+ */
+import type { MonorepoPackage } from "./structure-generator.js";
+export declare const MANAGED_START_PREFIX = "<!-- codebyplan:managed:start:";
+export declare const MANAGED_END_PREFIX = "<!-- codebyplan:managed:end:";
+export declare const MANAGED_MARKER_SUFFIX = " -->";
+export declare const HASH_MARKER_PREFIX = "<!-- codebyplan:hash:";
+/** Build the managed-start marker for a named section. */
+export declare function managedStartMarker(section: string): string;
+/** Build the managed-end marker for a named section. */
+export declare function managedEndMarker(section: string): string;
+/** Return true if `content` contains any codebyplan managed markers. */
+export declare function hasManagedMarkers(content: string): boolean;
+/**
+ * Validate marker integrity in `content`. Returns a list of human-readable
+ * problems (empty array = valid). Catches:
+ *   - start markers with no matching end marker (would cause pathological
+ *     regex backtracking in refreshManagedSections)
+ *   - end markers with no matching start marker
+ *   - duplicate section names (refresh would emit duplicate blocks)
+ *
+ * Callers should skip refresh for files with a non-empty result.
+ */
+export declare function validateManagedMarkers(content: string): string[];
+export interface ReadmeGenConfig {
+    /** Name from package.json */
+    name?: string;
+    /** Description from package.json */
+    description?: string;
+    /** Scripts from package.json (key: script name, value: command) */
+    scripts?: Record<string, string>;
+    /** Package manager string (e.g. "pnpm@10.12.4") */
+    packageManager?: string;
+    /** Tech stack entries — map of category label to comma-joined names */
+    techStack?: Record<string, string>;
+    /** Workspace packages (for monorepo root) */
+    packages?: MonorepoPackage[];
+    /** Install command override (e.g. "pnpm install") */
+    installCommand?: string;
+}
+export interface ReadmeUnit {
+    /** Display name */
+    name: string;
+    /** Relative path from project root (e.g. "apps/web") */
+    path: string;
+    /** Absolute path */
+    absPath: string;
+    /** True if this is the repo root */
+    isRoot: boolean;
+}
+/**
+ * Build managed sections from config.
+ * Returns a Record mapping section names to their rendered Markdown content
+ * (NOT wrapped in markers yet — wrapping happens in refreshManagedSections).
+ *
+ * DETERMINISTIC — no I/O, no timestamps, no random.
+ */
+export declare function buildManagedSections(config: ReadmeGenConfig): Record<string, string>;
+/**
+ * Compute a sha256 hash over the managed sections in deterministic JSON form.
+ * The hash is used as a drift sentinel; identical sections → identical hash.
+ *
+ * Input is serialized as JSON with sorted keys so map insertion order does not
+ * affect the hash.
+ */
+export declare function hashManagedContent(sections: Record<string, string>): string;
+/**
+ * Generate a full README.md from scratch for a unit that has no existing file.
+ * Includes the managed sections wrapped in their markers + a drift hash.
+ *
+ * DETERMINISTIC — no I/O.
+ */
+export declare function scaffoldReadme(config: ReadmeGenConfig): string;
+/**
+ * Replace ONLY the marker-bounded content inside an existing README.
+ * Prose outside any managed markers is preserved exactly.
+ *
+ * For sections that exist in `sections` but not in `existing`:
+ *   - They are appended at the end (before or after a trailing hash comment).
+ *
+ * For sections that exist in `existing` but not in `sections`:
+ *   - They are removed (markers + content stripped).
+ *
+ * The drift hash is updated to reflect the new content.
+ *
+ * Returns the refreshed README content (same trailing newline convention as
+ * the incoming string — adds one if the result would be empty).
+ */
+export declare function refreshManagedSections(existing: string, sections: Record<string, string>): string;
+export declare function escapeRegex(str: string): string;
+/**
+ * Extract the embedded drift hash from managed content, or null if absent.
+ * Shared by cli/claude/readme.ts and lib/agents-generator.ts.
+ */
+export declare function extractManagedHash(content: string): string | null;
+//# sourceMappingURL=readme-generator.d.ts.map

package/dist/lib/readme-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readme-generator.d.ts","sourceRoot":"","sources":["../../src/lib/readme-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAMhE,eAAO,MAAM,oBAAoB,mCAAmC,CAAC;AACrE,eAAO,MAAM,kBAAkB,iCAAiC,CAAC;AACjE,eAAO,MAAM,qBAAqB,SAAS,CAAC;AAC5C,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAE1D,0DAA0D;AAC1D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAK1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAuBhE;AAMD,MAAM,WAAW,eAAe;IAC9B,6BAA6B;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,mDAAmD;IACnD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;IAC7B,qDAAqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,MAAM,EAAE,OAAO,CAAC;CACjB;AA6DD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,eAAe,GACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA+BxB;AAMD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAO3E;AAMD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CA6B9D;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,MAAM,CAqFR;AAMD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQjE"}

package/dist/lib/repo-reader.d.ts

@@ -0,0 +1,59 @@
+/**
+ * RepoReader — a thin async interface for reading project-content files.
+ *
+ * The interface decouples CI generator logic (detectPlatforms, runCiInit,
+ * runScaffoldCiWorkflow) from the Node.js fs module so that:
+ *   - Unit tests can inject an InMemoryRepoReader without touching the disk.
+ *   - Future environments (WASM, Deno, edge) can supply alternative readers.
+ *
+ * Template-asset resolution (resolveTemplatesDir) is NOT routed through the
+ * reader — it resolves packaged assets, not project content.
+ *
+ * Write operations (mkdir, writeFile, renameSync) stay fs-direct in the call
+ * sites: the reader is read-only by design.
+ */
+/**
+ * Async interface for reading project-content files.
+ *
+ * All paths passed to these methods are resolved relative to the reader's
+ * root directory (for LocalFsReader) or against the in-memory file map (for
+ * InMemoryRepoReader in tests).
+ *
+ * Method semantics:
+ *   list(dir)  — returns the immediate child DIRECTORY names under dir (files
+ *                are excluded). Does NOT recurse. Never throws for a missing
+ *                dir — returns []. The sole consumer (detectPlatforms) only ever
+ *                enumerates sub-directories (apps/*, packages/*), and the
+ *                pre-refactor code filtered readdir() to directories; returning
+ *                dirs-only here preserves that byte-identical behaviour and maps
+ *                cleanly to a GitHub-tree reader (filter entries to type=dir).
+ *   read(p)    — returns the UTF-8 contents of the file at p. Throws if missing.
+ *   exists(p)  — returns true iff the path exists (file or dir).
+ */
+export interface RepoReader {
+    list(dir: string): Promise<string[]>;
+    read(filePath: string): Promise<string>;
+    exists(filePath: string): Promise<boolean>;
+}
+/**
+ * Production reader that resolves all paths against an absolute `rootDir`.
+ *
+ * Constructed with the project's absolute root directory. All paths passed to
+ * `list`, `read`, and `exists` are resolved with path.resolve(rootDir, p)
+ * when they are relative, or used as-is when already absolute.
+ *
+ * `list` returns only the immediate sub-DIRECTORY names (via readdir with
+ * withFileTypes, filtered to entries.isDirectory()). Because it never recurses,
+ * node_modules/.git isolation is naturally handled: a caller listing "apps"
+ * gets ["web", "mcp"] — not the contents of their node_modules trees, and loose
+ * files like apps/README.md are excluded (matching the pre-refactor behaviour).
+ */
+export declare class LocalFsReader implements RepoReader {
+    private readonly rootDir;
+    constructor(rootDir: string);
+    private resolve;
+    list(dir: string): Promise<string[]>;
+    read(filePath: string): Promise<string>;
+    exists(filePath: string): Promise<boolean>;
+}
+//# sourceMappingURL=repo-reader.d.ts.map

package/dist/lib/repo-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-reader.d.ts","sourceRoot":"","sources":["../../src/lib/repo-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AASH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACrC,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC5C;AAMD;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,YAAW,UAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,MAAM;IAE5C,OAAO,CAAC,OAAO;IAIT,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAcpC,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAavC,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CASjD"}