@baselane/packs 0.1.0

package/dist/render/bundle-union.js

@@ -0,0 +1,87 @@
+import { renderBundleFiles } from "./bundle.js";
+const SETTINGS_KEY = "settings.json";
+const MANIFEST_KEY = ".baselane/capabilities.json";
+/** Concatenate every rendered pack's hook entries per event, raw (unprefixed). The agent applies its
+ * BASELANE_MANAGED prefix later when merging into the developer's real settings — this is a
+ * different, earlier operation, so it must NOT prefix. For a single input this rebuilds the exact
+ * bytes render/claude.ts's settingsJson produced. */
+function mergeRenderedSettings(jsons) {
+    const byEvent = {};
+    for (const json of jsons) {
+        let parsed;
+        try {
+            parsed = JSON.parse(json);
+        }
+        catch {
+            continue;
+        }
+        const hooks = parsed.hooks;
+        if (!hooks || typeof hooks !== "object")
+            continue;
+        for (const [event, entries] of Object.entries(hooks)) {
+            if (!Array.isArray(entries))
+                continue;
+            (byEvent[event] ??= []).push(...entries);
+        }
+    }
+    return JSON.stringify({ hooks: byEvent }, null, 2) + "\n";
+}
+/** Union each manifest's capabilities, dedup by exact JSON identity, first occurrence wins. For a
+ * single input this rebuilds the exact bytes render/capabilities.ts's manifest produced. */
+function mergeCapabilityManifests(jsons) {
+    const capabilities = [];
+    const seen = new Set();
+    for (const json of jsons) {
+        let parsed;
+        try {
+            parsed = JSON.parse(json);
+        }
+        catch {
+            continue;
+        }
+        const list = parsed.capabilities;
+        if (!Array.isArray(list))
+            continue;
+        for (const c of list) {
+            const key = JSON.stringify(c);
+            if (!seen.has(key)) {
+                seen.add(key);
+                capabilities.push(c);
+            }
+        }
+    }
+    return JSON.stringify({ version: 1, capabilities }, null, 2) + "\n";
+}
+/** Unions the machine-level bundle files of an ordered (most-specific-first) effective pack set.
+ * settings.json hooks concatenate per event; capabilities manifests dedup; every other path is
+ * first-writer-wins with a collisions note on a differing later write. `renderBundleUnion([p])`
+ * byte-equals `renderBundleFiles(p)`. */
+export function renderBundleUnion(packs) {
+    const files = {};
+    const collisions = [];
+    const settings = [];
+    const manifests = [];
+    for (const pack of packs) {
+        for (const [path, content] of Object.entries(renderBundleFiles(pack))) {
+            if (path === SETTINGS_KEY) {
+                settings.push(content);
+                continue;
+            }
+            if (path === MANIFEST_KEY) {
+                manifests.push(content);
+                continue;
+            }
+            if (!(path in files)) {
+                files[path] = content;
+            }
+            else if (files[path] !== content && !collisions.includes(path)) {
+                collisions.push(path);
+            }
+        }
+    }
+    if (settings.length > 0)
+        files[SETTINGS_KEY] = mergeRenderedSettings(settings);
+    if (manifests.length > 0)
+        files[MANIFEST_KEY] = mergeCapabilityManifests(manifests);
+    return { files, collisions };
+}

package/dist/render/bundle.d.ts

@@ -0,0 +1,3 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+/** Machine-level bundle for the laptop agent: same artifact bodies, whitelist-rooted paths. */
+export declare function renderBundleFiles(pack: WorkflowPack): FileMap;

package/dist/render/bundle.js

@@ -0,0 +1,51 @@
+import { renderCapabilities } from "./capabilities.js";
+import { renderClaudeFiles } from "./claude.js";
+import { hasOrgMemoryFiles, renderBundleMemoryFiles, withMemoryScaffolding } from "./memory.js";
+import { hasOrgDesignAnalyze, renderBundleDesignFiles, withDesignAnalyzeScaffolding } from "./design.js";
+import { hasOrgTasksLedger, renderBundleTasksFiles, withTasksScaffolding } from "./tasks.js";
+import { hasOrgWikiBaselane, renderBundleWikiFiles, withWikiScaffolding } from "./wiki.js";
+import { hasOrgGraphCapability, renderBundleGraphFiles, withGraphScaffolding } from "./graph.js";
+import { hasOrgSystemMapCapability, renderBundleSystemMapFiles, withSystemMapScaffolding } from "./system-map.js";
+/** Machine-level bundle for the laptop agent: same artifact bodies, whitelist-rooted paths. */
+export function renderBundleFiles(pack) {
+    // An org-store memory+files (or tasks+ledger, wiki+baselane, or graph) capability is
+    // agent-managed on the laptop, not committed to the repo, so its command and Stop-hook
+    // reminder are added here instead of in render/render-pack.ts.
+    let claudePack = pack;
+    if (hasOrgMemoryFiles(pack))
+        claudePack = withMemoryScaffolding(claudePack, "org");
+    if (hasOrgTasksLedger(pack))
+        claudePack = withTasksScaffolding(claudePack, "org");
+    if (hasOrgWikiBaselane(pack))
+        claudePack = withWikiScaffolding(claudePack, "org");
+    if (hasOrgDesignAnalyze(pack))
+        claudePack = withDesignAnalyzeScaffolding(claudePack, "org");
+    if (hasOrgGraphCapability(pack))
+        claudePack = withGraphScaffolding(claudePack);
+    if (hasOrgSystemMapCapability(pack))
+        claudePack = withSystemMapScaffolding(claudePack);
+    const claude = renderClaudeFiles(claudePack);
+    // The capabilities manifest ships at the same `.baselane/capabilities.json` path as the repo
+    // render, so the laptop agent finds it in one known location — machine-readable regardless of
+    // which surface (repo or bundle) provisioned the capability.
+    const { manifest } = renderCapabilities(pack);
+    const bundle = {
+        ...renderBundleMemoryFiles(pack),
+        ...renderBundleDesignFiles(pack),
+        ...renderBundleTasksFiles(pack),
+        ...renderBundleWikiFiles(pack),
+        ...renderBundleGraphFiles(pack),
+        ...renderBundleSystemMapFiles(pack),
+        ...(manifest ? { ".baselane/capabilities.json": manifest } : {}),
+    };
+    for (const [path, content] of Object.entries(claude)) {
+        if (path === ".claude/settings.json") {
+            bundle["settings.json"] = content;
+            continue;
+        }
+        const m = /^\.claude\/(agents|commands|skills)\/(.+)$/.exec(path);
+        if (m)
+            bundle[`${m[1]}/${m[2]}`] = content;
+    }
+    return bundle;
+}

package/dist/render/capabilities.d.ts

@@ -0,0 +1,19 @@
+import type { WorkflowPack } from "../types.ts";
+/**
+ * AGENTS.md "## Harness capabilities" section + `.baselane/capabilities.json` manifest, or both
+ * null if the pack declares none.
+ *
+ * Bug #37.1 fix: AGENTS.md is a repo-only artifact (only `render-pack.ts`'s `renderAgentsMd`
+ * calls this for its `section`; `bundle.ts` only reads `manifest`) — so the longer explanatory
+ * note for a capability must only appear when the corresponding `hasRepoX` helper (the SAME
+ * store-aware gate that decides whether `render-pack.ts` actually scaffolds real files into the
+ * repo) is true. Before this fix, an org-store capability — real, but scaffolded only into the
+ * laptop bundle, never into this repo — still got its note rendered here, pointing a reader of
+ * this repo's AGENTS.md at a `.baselane/...` path that doesn't exist in this repo (a silent
+ * no-op from the repo's point of view, the inverse of "coming soon" honesty). The one-line
+ * `status()` entries above are left store-agnostic deliberately (see the comment on `status`).
+ */
+export declare function renderCapabilities(pack: WorkflowPack): {
+    section: string | null;
+    manifest: string | null;
+};

package/dist/render/capabilities.js

@@ -0,0 +1,86 @@
+import { MEMORY_AGENTS_NOTE, MEMORY_CLAUDE_MEM_AGENTS_NOTE, MEMORY_LETTA_AGENTS_NOTE, MEMORY_NATIVE_AGENTS_NOTE, MEMORY_VECTOR_AGENTS_NOTE, hasRepoMemoryClaudeMemMethod, hasRepoMemoryFilesMethod, hasRepoMemoryLettaMethod, hasRepoMemoryNativeMethod, hasRepoMemoryVectorMethod, } from "./memory.js";
+import { DESIGN_AGENTS_NOTE, hasRepoDesignCapability } from "./design.js";
+import { TASKS_AGENTS_NOTE, TASKS_BEADS_AGENTS_NOTE, TASKS_SPECKIT_AGENTS_NOTE, TASKS_TASKMASTER_AGENTS_NOTE, hasRepoTasksBeadsMethod, hasRepoTasksLedgerMethod, hasRepoTasksSpeckitMethod, hasRepoTasksTaskmasterMethod, } from "./tasks.js";
+import { WIKI_AGENTS_NOTE, WIKI_DEEPWIKI_AGENTS_NOTE, WIKI_DOCS_AGENTS_NOTE, hasRepoWikiBaselaneMethod, hasRepoWikiDeepwikiMethod, hasRepoWikiDocsMethod, } from "./wiki.js";
+import { GRAPH_AGENTS_NOTE, hasRepoGraphCapability } from "./graph.js";
+import { SYSTEM_MAP_AGENTS_NOTE, hasRepoSystemMapCapability } from "./system-map.js";
+const PROVISIONED_METHODS = {
+    memory: new Set(["files", "native", "claude-mem", "vector", "letta"]),
+    design: new Set(["author", "import", "analyze"]),
+    tasks: new Set(["ledger", "speckit", "taskmaster", "beads"]),
+    wiki: new Set(["baselane", "deepwiki", "docs"]),
+    graph: new Set(["imports", "graphify", "aider", "lsp", "sourcegraph"]),
+    "system-map": new Set(["analyze", "analyze+llm"]),
+};
+/** This status is store-agnostic on purpose: it feeds `.baselane/capabilities.json`, which ships
+ * identically to the repo and the laptop bundle, and a method that's genuinely implemented is
+ * "provisioned" regardless of which surface (repo file or agent-managed laptop bundle) ends up
+ * holding its scaffolding — see the bug-#37.1 note below for the part of this file that DOES
+ * need to be store-aware. */
+function status(capability) {
+    return PROVISIONED_METHODS[capability.type]?.has(capability.method) ? "provisioned" : "coming soon";
+}
+/**
+ * AGENTS.md "## Harness capabilities" section + `.baselane/capabilities.json` manifest, or both
+ * null if the pack declares none.
+ *
+ * Bug #37.1 fix: AGENTS.md is a repo-only artifact (only `render-pack.ts`'s `renderAgentsMd`
+ * calls this for its `section`; `bundle.ts` only reads `manifest`) — so the longer explanatory
+ * note for a capability must only appear when the corresponding `hasRepoX` helper (the SAME
+ * store-aware gate that decides whether `render-pack.ts` actually scaffolds real files into the
+ * repo) is true. Before this fix, an org-store capability — real, but scaffolded only into the
+ * laptop bundle, never into this repo — still got its note rendered here, pointing a reader of
+ * this repo's AGENTS.md at a `.baselane/...` path that doesn't exist in this repo (a silent
+ * no-op from the repo's point of view, the inverse of "coming soon" honesty). The one-line
+ * `status()` entries above are left store-agnostic deliberately (see the comment on `status`).
+ */
+export function renderCapabilities(pack) {
+    const capabilities = pack.capabilities;
+    if (!capabilities || capabilities.length === 0)
+        return { section: null, manifest: null };
+    const lines = ["## Harness capabilities", ""];
+    for (const c of capabilities)
+        lines.push(`- ${c.type} · ${c.store} · ${c.method} — ${status(c)}`);
+    // #9: each note is method-specific — gate it on the method it actually describes, not on "any
+    // method of this type", so a native/deepwiki/speckit pack is never handed a note that points at a
+    // path or command that method never scaffolds. (design's note is method-agnostic: every design
+    // method produces the same DESIGN.md, so it stays gated on "any design capability".)
+    if (hasRepoMemoryFilesMethod(pack))
+        lines.push("", MEMORY_AGENTS_NOTE);
+    if (hasRepoMemoryNativeMethod(pack))
+        lines.push("", MEMORY_NATIVE_AGENTS_NOTE);
+    if (hasRepoMemoryClaudeMemMethod(pack))
+        lines.push("", MEMORY_CLAUDE_MEM_AGENTS_NOTE);
+    if (hasRepoMemoryVectorMethod(pack))
+        lines.push("", MEMORY_VECTOR_AGENTS_NOTE);
+    if (hasRepoMemoryLettaMethod(pack))
+        lines.push("", MEMORY_LETTA_AGENTS_NOTE);
+    if (hasRepoDesignCapability(pack))
+        lines.push("", DESIGN_AGENTS_NOTE);
+    if (hasRepoTasksLedgerMethod(pack))
+        lines.push("", TASKS_AGENTS_NOTE);
+    if (hasRepoTasksSpeckitMethod(pack))
+        lines.push("", TASKS_SPECKIT_AGENTS_NOTE);
+    if (hasRepoTasksTaskmasterMethod(pack))
+        lines.push("", TASKS_TASKMASTER_AGENTS_NOTE);
+    if (hasRepoTasksBeadsMethod(pack))
+        lines.push("", TASKS_BEADS_AGENTS_NOTE);
+    if (hasRepoWikiBaselaneMethod(pack))
+        lines.push("", WIKI_AGENTS_NOTE);
+    if (hasRepoWikiDeepwikiMethod(pack))
+        lines.push("", WIKI_DEEPWIKI_AGENTS_NOTE);
+    if (hasRepoWikiDocsMethod(pack))
+        lines.push("", WIKI_DOCS_AGENTS_NOTE);
+    if (hasRepoGraphCapability(pack))
+        lines.push("", GRAPH_AGENTS_NOTE);
+    if (hasRepoSystemMapCapability(pack))
+        lines.push("", SYSTEM_MAP_AGENTS_NOTE);
+    const section = lines.join("\n");
+    // Provenance is builder/library metadata (increment 26) — never shipped into a rendered file.
+    // This manifest is the ONLY renderer that serializes whole block objects, so it drops the key
+    // here (rest-destructuring siblings are exempt from noUnusedLocals). No-op for provenance-free
+    // packs: the emitted JSON is byte-identical, so every golden stays untouched.
+    const manifestCapabilities = capabilities.map(({ provenance: _prov, ...c }) => c);
+    const manifest = JSON.stringify({ version: 1, capabilities: manifestCapabilities }, null, 2) + "\n";
+    return { section, manifest };
+}

package/dist/render/claude.d.ts

@@ -0,0 +1,3 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+/** Claude Code output: thin CLAUDE.md importer + native agent/command/hook artifacts. */
+export declare function renderClaudeFiles(pack: WorkflowPack): FileMap;

package/dist/render/claude.js

@@ -0,0 +1,92 @@
+/** One native SKILL.md: required name+description frontmatter, optional governance keys
+ * (user-invocable / disable-model-invocation / allowed-tools), optional license key + attribution
+ * comment (retained import notice), then the body verbatim. category/provenance are baselane-side
+ * and never written here. Governance keys sit after description and before license, so a skill with
+ * none of them renders byte-identically to before. */
+function skillMd(s) {
+    const fm = [`name: ${s.name}`, `description: ${s.description}`];
+    if (s.userInvocable !== undefined)
+        fm.push(`user-invocable: ${s.userInvocable}`);
+    if (s.disableModelInvocation !== undefined)
+        fm.push(`disable-model-invocation: ${s.disableModelInvocation}`);
+    if (s.allowedTools !== undefined && s.allowedTools.length > 0)
+        fm.push(`allowed-tools: ${s.allowedTools.join(", ")}`);
+    if (s.attribution)
+        fm.push(`license: ${s.attribution.license}`);
+    const notice = s.attribution
+        ? `<!-- adapted from ${s.attribution.source} (${s.attribution.license}) — ${s.attribution.url} -->\n\n`
+        : "";
+    const body = s.body.endsWith("\n") ? s.body : `${s.body}\n`;
+    return `---\n${fm.join("\n")}\n---\n\n${notice}${body}`;
+}
+function claudeMd(pack) {
+    const lines = ["# CLAUDE.md", "", "@AGENTS.md", ""];
+    const artifacts = [];
+    for (const a of pack.agents)
+        artifacts.push(`- Subagent: \`.claude/agents/${a.name}.md\``);
+    for (const c of pack.commands)
+        artifacts.push(`- Command: \`.claude/commands/${c.name}.md\``);
+    if (pack.hooks.length > 0)
+        artifacts.push("- Hooks: see `.claude/settings.json`");
+    for (const s of pack.skills ?? []) {
+        artifacts.push(`- Skill: \`.claude/skills/${s.name}/SKILL.md\` — ${s.description}`);
+    }
+    // #34: a zero-artifact pack has no native Claude Code implementation to announce. Emitting the
+    // preamble followed by an empty list is a false identity — render only the @AGENTS.md importer.
+    if (artifacts.length > 0) {
+        lines.push("This project defines a native Claude Code implementation of this workflow pack:");
+        lines.push(...artifacts, "");
+    }
+    return lines.join("\n");
+}
+function settingsJson(pack) {
+    const byEvent = {};
+    for (const h of pack.hooks) {
+        const command = h.action === "run-command" ? h.command : `echo ${JSON.stringify(h.message)}`;
+        const entry = {
+            matcher: h.matcher,
+            hooks: [{ type: "command", command }],
+        };
+        (byEvent[h.event] ??= []).push(entry);
+    }
+    return JSON.stringify({ hooks: byEvent }, null, 2) + "\n";
+}
+/** Nested-YAML `mcpServers:` block for an agent's frontmatter (server name → command/args). Emitted
+ * only when present, so an agent without MCP servers renders exactly as before. Values are quoted
+ * with JSON.stringify — valid YAML and byte-matching the harness bundles' quoted args. */
+function mcpServersYaml(servers) {
+    const lines = ["mcpServers:"];
+    for (const [name, cfg] of Object.entries(servers)) {
+        lines.push(`  ${name}:`, `    command: ${cfg.command}`);
+        if (cfg.args && cfg.args.length > 0) {
+            lines.push("    args:");
+            for (const a of cfg.args)
+                lines.push(`      - ${JSON.stringify(a)}`);
+        }
+    }
+    return lines.join("\n");
+}
+function agentMd(a) {
+    const mcp = a.mcpServers && Object.keys(a.mcpServers).length > 0 ? `\n${mcpServersYaml(a.mcpServers)}` : "";
+    return `---\nname: ${a.name}\ndescription: ${a.description}\ntools: ${a.tools.join(", ")}\nmodel: ${a.model}${mcp}\n---\n\n${a.prompt}\n`;
+}
+/** Claude Code output: thin CLAUDE.md importer + native agent/command/hook artifacts. */
+export function renderClaudeFiles(pack) {
+    const files = { "CLAUDE.md": claudeMd(pack) };
+    for (const a of pack.agents) {
+        files[`.claude/agents/${a.name}.md`] = agentMd(a);
+    }
+    for (const c of pack.commands) {
+        files[`.claude/commands/${c.name}.md`] =
+            `---\ndescription: ${c.description}\nargument-hint: ${c.argument_hint}\n---\n\n${c.prompt}\n`;
+    }
+    for (const s of pack.skills ?? []) {
+        files[`.claude/skills/${s.name}/SKILL.md`] = skillMd(s);
+        for (const r of s.references ?? []) {
+            files[`.claude/skills/${s.name}/${r.name}.md`] = r.body.endsWith("\n") ? r.body : `${r.body}\n`;
+        }
+    }
+    if (pack.hooks.length > 0)
+        files[".claude/settings.json"] = settingsJson(pack);
+    return files;
+}

package/dist/render/design.d.ts

@@ -0,0 +1,27 @@
+import type { Capability, FileMap, WorkflowPack } from "../types.ts";
+/** Google-Stitch-standard DESIGN.md, built from the design capability's config tokens (all optional). */
+export declare function renderDesignMd(capability: Capability): string;
+/** The AGENTS.md capabilities-section note for a design+author capability, regardless of store. */
+export declare const DESIGN_AGENTS_NOTE: string;
+/** DESIGN.md for the `import` method: parses `capability.config.tokens`, then reuses the exact
+ * same 9-section builder `author` uses. A parse failure falls back to `author`'s own defaults,
+ * with a visible note rather than crashing. */
+export declare function renderImportDesignMd(capability: Capability): string;
+/** DESIGN.md skeleton for the `analyze` method — same 9 headings as the real document, each
+ * still holding a TODO marker naming what to extract and from where. */
+export declare function renderAnalyzeDesignSkeleton(capability: Capability): string;
+/** True if this store has a real (non-"coming soon") design capability that would actually
+ * scaffold a DESIGN.md — used by capabilities.ts to gate the AGENTS.md note (bug #37.1). */
+export declare function hasRepoDesignCapability(pack: WorkflowPack): boolean;
+export declare function hasOrgDesignCapability(pack: WorkflowPack): boolean;
+/** `DESIGN.md` at the repo root, for a repo-store design capability using `author`, `import`,
+ * or `analyze` — whichever is present. */
+export declare function renderRepoDesignFiles(pack: WorkflowPack): FileMap;
+/** `DESIGN.md` in the laptop bundle, for an org-store design capability using `author`,
+ * `import`, or `analyze` — whichever is present. */
+export declare function renderBundleDesignFiles(pack: WorkflowPack): FileMap;
+export declare function hasRepoDesignAnalyze(pack: WorkflowPack): boolean;
+export declare function hasOrgDesignAnalyze(pack: WorkflowPack): boolean;
+/** Adds the /design-analyze command to a pack, without disturbing what it already declares.
+ * Only called when a design+analyze capability is present for the given store. */
+export declare function withDesignAnalyzeScaffolding(pack: WorkflowPack, store: "org" | "repo"): WorkflowPack;