@baseline-studio/cli 2.2.0

package/bin/baseline

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/index.js');

package/dist/commands/context.d.ts

@@ -0,0 +1 @@
+export declare function context(name?: string): Promise<void>;

package/dist/commands/context.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.context = context;
+const readline_1 = require("readline");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const js_yaml_1 = require("js-yaml");
+const config_js_1 = require("../config.js");
+let rlClosed = false;
+function ask(rl, question) {
+    if (rlClosed)
+        return Promise.resolve("");
+    return new Promise((resolve) => {
+        try {
+            rl.question(question, resolve);
+        }
+        catch {
+            resolve("");
+        }
+    });
+}
+async function context(name) {
+    if (name) {
+        await contextAdd(name);
+    }
+    else {
+        await contextRefresh();
+    }
+}
+/** Re-run context prompts for existing files */
+async function contextRefresh() {
+    const config = (0, config_js_1.readConfig)();
+    const cwd = process.cwd();
+    const contextDir = (0, path_1.join)(cwd, config.client.contextPath || "./context");
+    // Load prompts from local skills (they were pulled from core via update)
+    const skillsDir = (0, path_1.join)(cwd, "skills");
+    const prompts = loadPromptsFromLocal(cwd);
+    if (Object.keys(prompts).length === 0) {
+        console.error("  Error: No context prompts found. Run `baseline update` first.\n");
+        process.exit(1);
+    }
+    const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    rl.on("close", () => { rlClosed = true; });
+    console.log(`\n  Baseline Context — Update Context Files`);
+    console.log(`  ────────────────────────────────────────\n`);
+    console.log(`  Existing answers shown in [brackets]. Press Enter to keep them.\n`);
+    let filesUpdated = 0;
+    for (const [ctxFile, prompt] of Object.entries(prompts)) {
+        const fullPath = (0, path_1.join)(contextDir, ctxFile);
+        const existingContent = (0, fs_1.existsSync)(fullPath) ? (0, fs_1.readFileSync)(fullPath, "utf-8") : "";
+        const existingAnswers = parseExistingAnswers(existingContent, prompt.questions);
+        console.log(`  ── ${prompt.title} ──\n`);
+        const answers = [];
+        for (let i = 0; i < prompt.questions.length; i++) {
+            const q = prompt.questions[i];
+            const existing = existingAnswers[i] || "";
+            const hint = existing ? ` [${truncate(existing, 60)}]` : "";
+            const answer = await ask(rl, `  ${q}${hint}\n  > `);
+            const final = answer.trim() || existing;
+            if (final) {
+                answers.push(`**${q}**\n${final}`);
+            }
+            console.log();
+        }
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(fullPath), { recursive: true });
+        if (answers.length > 0) {
+            (0, fs_1.writeFileSync)(fullPath, `# ${prompt.title}\n\n${answers.join("\n\n")}\n`);
+            filesUpdated++;
+        }
+        else if (!(0, fs_1.existsSync)(fullPath)) {
+            (0, fs_1.writeFileSync)(fullPath, `# ${prompt.title}\n\n<!-- Add your content here -->\n`);
+        }
+    }
+    rl.close();
+    console.log(`  ────────────────────────────────────────`);
+    console.log(`  Updated ${filesUpdated} context files.\n`);
+}
+/** Create a new context file and wire it into context.yaml */
+async function contextAdd(name) {
+    const config = (0, config_js_1.readConfig)();
+    const cwd = process.cwd();
+    const contextDir = (0, path_1.join)(cwd, config.client.contextPath || "./context");
+    const skillsDir = (0, path_1.join)(cwd, "skills");
+    // Normalize name
+    const fileName = name.endsWith(".md") ? name : `${name}.md`;
+    const filePath = (0, path_1.join)(contextDir, "extended", fileName);
+    if ((0, fs_1.existsSync)(filePath)) {
+        console.error(`\n  Error: context/extended/${fileName} already exists.\n`);
+        process.exit(1);
+    }
+    // Get available skills
+    const skills = [];
+    if ((0, fs_1.existsSync)(skillsDir)) {
+        for (const entry of (0, fs_1.readdirSync)(skillsDir)) {
+            const manifestPath = (0, path_1.join)(skillsDir, entry, "manifest.yaml");
+            if ((0, fs_1.existsSync)(manifestPath)) {
+                skills.push(entry);
+            }
+        }
+    }
+    skills.sort();
+    const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    rl.on("close", () => { rlClosed = true; });
+    console.log(`\n  Baseline Context — Add New File`);
+    console.log(`  ───────────────────────────────\n`);
+    console.log(`  Creating: context/extended/${fileName}\n`);
+    // Ask for a title
+    const title = await ask(rl, `  Title for this context file: `);
+    const fileTitle = title.trim() || name.replace(/\.md$/, "").replace(/-/g, " ");
+    console.log();
+    // Ask which skills should use this context
+    console.log(`  Which skills should use this context file?`);
+    console.log(`  Available skills:\n`);
+    for (let i = 0; i < skills.length; i++) {
+        console.log(`    ${i + 1}. ${skills[i]}`);
+    }
+    console.log();
+    const selection = await ask(rl, `  Enter skill numbers (comma-separated) or "all":\n  > `);
+    let selectedSkills;
+    if (selection.trim().toLowerCase() === "all") {
+        selectedSkills = [...skills];
+    }
+    else {
+        const indices = selection
+            .split(",")
+            .map((s) => parseInt(s.trim(), 10) - 1)
+            .filter((i) => i >= 0 && i < skills.length);
+        selectedSkills = indices.map((i) => skills[i]);
+    }
+    // Create the file
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(filePath), { recursive: true });
+    (0, fs_1.writeFileSync)(filePath, `# ${fileTitle}\n\n<!-- Add your content here -->\n`);
+    // Update context.yaml
+    const contextYamlPath = (0, path_1.join)(contextDir, "context.yaml");
+    let contextYaml = { core: ["identity.md", "voice.md"], extended: {} };
+    if ((0, fs_1.existsSync)(contextYamlPath)) {
+        const parsed = (0, js_yaml_1.load)((0, fs_1.readFileSync)(contextYamlPath, "utf-8"));
+        if (parsed)
+            contextYaml = parsed;
+        if (!contextYaml.extended)
+            contextYaml.extended = {};
+    }
+    if (selectedSkills.length > 0) {
+        contextYaml.extended[fileName] = selectedSkills.sort();
+    }
+    // Write context.yaml back as formatted YAML
+    let yamlOut = "# Maps context files to skills. Merged with skill manifests during execution.\n";
+    yamlOut += "core:\n";
+    for (const c of contextYaml.core || ["identity.md", "voice.md"]) {
+        yamlOut += `  - ${c}\n`;
+    }
+    yamlOut += "extended:\n";
+    const entries = Object.entries(contextYaml.extended || {}).sort(([a], [b]) => a.localeCompare(b));
+    for (const [file, skillList] of entries) {
+        yamlOut += `  ${file}:\n`;
+        for (const s of skillList) {
+            yamlOut += `    - ${s}\n`;
+        }
+    }
+    (0, fs_1.writeFileSync)(contextYamlPath, yamlOut);
+    rl.close();
+    console.log(`\n  ───────────────────────────────`);
+    console.log(`  Created context/extended/${fileName}`);
+    if (selectedSkills.length > 0) {
+        console.log(`  Wired to: ${selectedSkills.join(", ")}`);
+    }
+    console.log(`  Updated context/context.yaml\n`);
+}
+/** Load context prompts from the local context-prompts.yaml or skill manifests */
+function loadPromptsFromLocal(cwd) {
+    // First try context-prompts.yaml bundled with the skills
+    // Since we don't bundle context-prompts.yaml in client repos,
+    // we fetch it from the core repo via config
+    const config = (0, config_js_1.readConfig)();
+    const { cloneAtTag, getLatestTag } = require("../git.js");
+    const latest = getLatestTag(config.coreRepo);
+    if (!latest)
+        return {};
+    const tmpDir = cloneAtTag(config.coreRepo, latest);
+    const promptsPath = (0, path_1.join)(tmpDir, "context-prompts.yaml");
+    let prompts = {};
+    if ((0, fs_1.existsSync)(promptsPath)) {
+        prompts = (0, js_yaml_1.load)((0, fs_1.readFileSync)(promptsPath, "utf-8"));
+    }
+    const { rmSync } = require("fs");
+    rmSync(tmpDir, { recursive: true });
+    return prompts;
+}
+/** Parse existing answers from a context file */
+function parseExistingAnswers(content, questions) {
+    const answers = [];
+    for (const q of questions) {
+        const marker = `**${q}**`;
+        const idx = content.indexOf(marker);
+        if (idx === -1) {
+            answers.push("");
+            continue;
+        }
+        const afterMarker = content.slice(idx + marker.length).trimStart();
+        // Find the next question marker or end of file
+        const nextMarkerIdx = afterMarker.indexOf("**");
+        const answerText = nextMarkerIdx > 0
+            ? afterMarker.slice(0, nextMarkerIdx).trim()
+            : afterMarker.trim();
+        answers.push(answerText);
+    }
+    return answers;
+}
+function truncate(str, max) {
+    const oneLine = str.replace(/\n/g, " ").trim();
+    return oneLine.length > max ? oneLine.slice(0, max - 3) + "..." : oneLine;
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const readline_1 = require("readline");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const js_yaml_1 = require("js-yaml");
+const git_js_1 = require("../git.js");
+const child_process_1 = require("child_process");
+const SYNC_DIRS = ["skills", "frameworks", "scripts", "cli"];
+let rlClosed = false;
+function ask(rl, question) {
+    if (rlClosed)
+        return Promise.resolve("");
+    return new Promise((resolve) => {
+        try {
+            rl.question(question, resolve);
+        }
+        catch {
+            resolve("");
+        }
+    });
+}
+async function init() {
+    const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    rl.on("close", () => { rlClosed = true; });
+    console.log(`\n  Baseline System — New Client Setup`);
+    console.log(`  ───────────────────────────────────\n`);
+    // 1. Gather basic info
+    const clientName = await ask(rl, "  Client name: ");
+    const folderName = await ask(rl, `  Folder name (${clientName.toLowerCase().replace(/\s+/g, "-")}-system): `);
+    const folder = folderName.trim() ||
+        `${clientName.toLowerCase().replace(/\s+/g, "-")}-system`;
+    const coreRepo = await ask(rl, "  Core repo (TrentM6/baseline-core): ");
+    const repo = coreRepo.trim() || "TrentM6/baseline-core";
+    const destDir = (0, path_1.join)(process.cwd(), folder);
+    if ((0, fs_1.existsSync)(destDir)) {
+        console.error(`\n  Error: ${folder} already exists.\n`);
+        rl.close();
+        process.exit(1);
+    }
+    // 2. Fetch latest from core
+    console.log(`\n  Fetching latest from ${repo}...`);
+    const latest = (0, git_js_1.getLatestTag)(repo);
+    if (!latest) {
+        console.error("  Could not determine latest version.\n");
+        rl.close();
+        process.exit(1);
+    }
+    console.log(`  Using v${latest}\n`);
+    const tmpDir = (0, git_js_1.cloneAtTag)(repo, latest);
+    // 3. Create folder structure
+    (0, fs_1.mkdirSync)((0, path_1.join)(destDir, "context", "core"), { recursive: true });
+    (0, fs_1.mkdirSync)((0, path_1.join)(destDir, "context", "extended"), { recursive: true });
+    // 4. Copy skills, frameworks, scripts, cli
+    for (const dir of SYNC_DIRS) {
+        const srcDir = (0, path_1.join)(tmpDir, dir);
+        if ((0, fs_1.existsSync)(srcDir)) {
+            (0, fs_1.cpSync)(srcDir, (0, path_1.join)(destDir, dir), { recursive: true });
+        }
+    }
+    // Remove CLI source files (clients only need bin/, dist/, package.json)
+    const cliCleanup = ["src", "tsconfig.json", "package-lock.json"];
+    for (const item of cliCleanup) {
+        const p = (0, path_1.join)(destDir, "cli", item);
+        if ((0, fs_1.existsSync)(p))
+            (0, fs_1.rmSync)(p, { recursive: true });
+    }
+    // 5. Collect unique context file paths from manifests
+    const contextFiles = collectContextPaths(tmpDir);
+    // 6. Load context-prompts.yaml from core
+    const promptsPath = (0, path_1.join)(tmpDir, "context-prompts.yaml");
+    let prompts = {};
+    if ((0, fs_1.existsSync)(promptsPath)) {
+        prompts = (0, js_yaml_1.load)((0, fs_1.readFileSync)(promptsPath, "utf-8"));
+    }
+    // 7. Ask questions and write context files
+    console.log("  Let's set up your context files.\n");
+    console.log("  (Press Enter to skip any question)\n");
+    for (const ctxFile of contextFiles) {
+        const prompt = prompts[ctxFile];
+        if (!prompt) {
+            // Create empty template for files without prompts
+            const fullPath = (0, path_1.join)(destDir, "context", ctxFile);
+            (0, fs_1.mkdirSync)((0, path_1.dirname)(fullPath), { recursive: true });
+            (0, fs_1.writeFileSync)(fullPath, `# ${ctxFile}\n\n<!-- Add your content here -->\n`);
+            continue;
+        }
+        console.log(`  ── ${prompt.title} ──\n`);
+        const answers = [];
+        for (const q of prompt.questions) {
+            const answer = await ask(rl, `  ${q}\n  > `);
+            if (answer.trim()) {
+                answers.push(`**${q}**\n${answer.trim()}`);
+            }
+            console.log();
+        }
+        const fullPath = (0, path_1.join)(destDir, "context", ctxFile);
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(fullPath), { recursive: true });
+        if (answers.length > 0) {
+            (0, fs_1.writeFileSync)(fullPath, `# ${prompt.title}\n\n${answers.join("\n\n")}\n`);
+        }
+        else {
+            (0, fs_1.writeFileSync)(fullPath, `# ${prompt.title}\n\n<!-- Add your content here -->\n`);
+        }
+    }
+    // 8. Create context.yaml
+    const contextYaml = buildContextYaml(tmpDir, contextFiles);
+    (0, fs_1.writeFileSync)((0, path_1.join)(destDir, "context", "context.yaml"), contextYaml);
+    // 9. Create baseline.config.json
+    const config = {
+        version: latest,
+        coreRepo: repo,
+        lastUpdated: new Date().toISOString(),
+        client: {
+            name: clientName,
+            contextPath: "./context",
+        },
+    };
+    (0, fs_1.writeFileSync)((0, path_1.join)(destDir, "baseline.config.json"), JSON.stringify(config, null, 2) + "\n");
+    // 10. Create CLAUDE.md
+    const templatePath = (0, path_1.join)(tmpDir, "claude-template.md");
+    if ((0, fs_1.existsSync)(templatePath)) {
+        let template = (0, fs_1.readFileSync)(templatePath, "utf-8");
+        template = template.replace(/\{client_name\}/g, clientName);
+        (0, fs_1.writeFileSync)((0, path_1.join)(destDir, "CLAUDE.md"), template);
+    }
+    else {
+        (0, fs_1.writeFileSync)((0, path_1.join)(destDir, "CLAUDE.md"), generateClaudeMd(clientName));
+    }
+    // 11. Create root package.json for local CLI access
+    const rootPkg = {
+        name: `${clientName.toLowerCase().replace(/\s+/g, "-")}-system`,
+        version: "1.0.0",
+        private: true,
+        description: `${clientName} Baseline System`,
+        dependencies: {
+            "baseline-cli": "file:cli",
+        },
+    };
+    (0, fs_1.writeFileSync)((0, path_1.join)(destDir, "package.json"), JSON.stringify(rootPkg, null, 2) + "\n");
+    // 12. Install CLI locally so npx baseline works
+    console.log(`\n  Installing CLI...`);
+    (0, child_process_1.execSync)("npm install --silent", { cwd: destDir, stdio: "pipe" });
+    // 13. Create .gitignore
+    (0, fs_1.writeFileSync)((0, path_1.join)(destDir, ".gitignore"), "node_modules/\n.DS_Store\n");
+    // 14. Initialize git repo
+    (0, child_process_1.execSync)("git init", { cwd: destDir, stdio: "pipe" });
+    (0, child_process_1.execSync)("git add -A", { cwd: destDir, stdio: "pipe" });
+    (0, child_process_1.execSync)(`git commit -m "Initialize ${clientName} Baseline System (v${latest})"`, { cwd: destDir, stdio: "pipe" });
+    // Clean up
+    (0, fs_1.rmSync)(tmpDir, { recursive: true });
+    rl.close();
+    console.log(`  ───────────────────────────────────`);
+    console.log(`  ${clientName} system created at ./${folder}`);
+    console.log(`  Version: v${latest}`);
+    console.log(`  Skills: ${SYNC_DIRS.filter((d) => d !== "cli").map((d) => (0, fs_1.existsSync)((0, path_1.join)(destDir, d)) ? (0, fs_1.readdirSync)((0, path_1.join)(destDir, d)).filter((f) => !f.startsWith(".") && !f.startsWith("_")).length : 0).join(" | ")}`);
+    console.log(`\n  Next steps:`);
+    console.log(`    cd ${folder}`);
+    console.log(`    Edit context/ files to add more detail`);
+    console.log(`    Run \`npx baseline status\` to check for updates\n`);
+}
+/** Scan all skill manifests and return unique context file paths (relative to context/) */
+function collectContextPaths(coreDir) {
+    const skillsDir = (0, path_1.join)(coreDir, "skills");
+    if (!(0, fs_1.existsSync)(skillsDir))
+        return [];
+    const paths = new Set();
+    // Always include core files
+    paths.add("core/identity.md");
+    paths.add("core/voice.md");
+    for (const skill of (0, fs_1.readdirSync)(skillsDir)) {
+        const manifestPath = (0, path_1.join)(skillsDir, skill, "manifest.yaml");
+        if (!(0, fs_1.existsSync)(manifestPath))
+            continue;
+        try {
+            const manifest = (0, js_yaml_1.load)((0, fs_1.readFileSync)(manifestPath, "utf-8"));
+            if (!manifest?.context)
+                continue;
+            for (const section of ["core", "extended"]) {
+                const entries = manifest.context[section];
+                if (!entries)
+                    continue;
+                for (const ctxPath of entries) {
+                    const match = ctxPath.match(/context\/\{client\}\/(.+)/);
+                    if (match)
+                        paths.add(match[1]);
+                }
+            }
+        }
+        catch {
+            // Skip unparseable manifests
+        }
+    }
+    // Sort: core first, then extended
+    return [...paths].sort((a, b) => {
+        if (a.startsWith("core/") && !b.startsWith("core/"))
+            return -1;
+        if (!a.startsWith("core/") && b.startsWith("core/"))
+            return 1;
+        return a.localeCompare(b);
+    });
+}
+/** Build context.yaml mapping context files to skills */
+function buildContextYaml(coreDir, contextFiles) {
+    const skillsDir = (0, path_1.join)(coreDir, "skills");
+    const extendedMap = new Map();
+    if ((0, fs_1.existsSync)(skillsDir)) {
+        for (const skill of (0, fs_1.readdirSync)(skillsDir)) {
+            const manifestPath = (0, path_1.join)(skillsDir, skill, "manifest.yaml");
+            if (!(0, fs_1.existsSync)(manifestPath))
+                continue;
+            try {
+                const manifest = (0, js_yaml_1.load)((0, fs_1.readFileSync)(manifestPath, "utf-8"));
+                if (!manifest?.context?.extended)
+                    continue;
+                for (const ctxPath of manifest.context.extended) {
+                    const match = ctxPath.match(/context\/\{client\}\/extended\/(.+)/);
+                    if (!match)
+                        continue;
+                    const file = match[1];
+                    if (!extendedMap.has(file))
+                        extendedMap.set(file, []);
+                    extendedMap.get(file).push(skill);
+                }
+            }
+            catch {
+                // Skip
+            }
+        }
+    }
+    let yaml = "# Maps context files to skills. Merged with skill manifests during execution.\n";
+    yaml += "core:\n";
+    yaml += "  - identity.md       # loaded by all skills\n";
+    yaml += "  - voice.md          # loaded by all skills\n";
+    yaml += "extended:\n";
+    for (const [file, skills] of [...extendedMap.entries()].sort()) {
+        yaml += `  ${file}:\n`;
+        for (const s of skills.sort()) {
+            yaml += `    - ${s}\n`;
+        }
+    }
+    return yaml;
+}
+/** Generate a CLAUDE.md for the client if no template exists in core */
+function generateClaudeMd(clientName) {
+    return `# ${clientName} — Baseline System
+
+> This file is automatically loaded at the start of every Claude Code session. It enforces consistent skill execution.
+
+---
+
+## What This Project Is
+
+The Baseline System is a complete AI system for product work with four components:
+
+1. **Skills** (\`skills/\`) — Domain expertise (12 universal skills)
+2. **Context** (\`context/\`) — Business-specific knowledge
+3. **Frameworks** (\`frameworks/\`) — Reusable methodologies
+4. **Scripts** (\`scripts/\`) — Delivery to external tools
+
+Skills provide methodology. Context personalizes output. Frameworks provide reusable patterns. Scripts deliver to tools.
+
+---
+
+## Skill Execution Protocol
+
+When a user invokes any skill — by name, by file path, or by describing a task that maps to a skill — you MUST follow this exact sequence. Do not skip steps.
+
+### Step 1: Identify the Skill
+
+Match the user's request to a skill using this table:
+
+| Task | Skill |
+|------|-------|
+| Strategic decisions, roadmaps, prioritization | \`strategic-advisory\` |
+| User research, interviews, synthesis | \`research-synthesis\` |
+| PRDs, specs, briefs, stakeholder updates | \`product-communications\` |
+| Interface design, wireframes, UI copy | \`ux-design\` |
+| Metrics, dashboards, A/B tests | \`product-analytics\` |
+| Coded prototypes, demos, POCs | \`prototyping\` |
+| Planning, tracking, sprints | \`project-management\` |
+| User guides, help center, release notes | \`technical-documentation\` |
+| Presentations, graphics, diagrams | \`brand-design\` |
+| LinkedIn content, website copy, campaigns | \`marketing\` |
+| Outreach, proposals, discovery calls | \`sales\` |
+| Creating new skills | \`skill-building\` |
+
+### Step 2: Read the Manifest
+
+Every skill has a \`manifest.yaml\` in its folder that lists every file the skill needs. Read it:
+
+\`\`\`
+skills/[skill-name]/manifest.yaml
+\`\`\`
+
+This is the source of truth for what files to load. Do not guess or rely on file paths embedded in markdown prose.
+
+### Step 3: Load All Files Listed in the Manifest
+
+The manifest has three sections. Load them in this order:
+
+1. **\`always_load\`** — Read every file in this list. These are the skill file and framework files. Always load all of them.
+
+2. **\`context\`** — These paths use \`{client}\` as a placeholder. Replace \`{client}\` with the context folder path for this project. Read every file under \`core\` and \`extended\`. If a context file does not exist, skip it and continue — not all context files may be populated.
+
+3. **\`references\`** — These are detailed reference materials. Load them when the task benefits from detailed guidance (e.g., document templates when writing a PRD, content playbooks when creating a campaign). For straightforward tasks, you may skip references.
+
+**Do not skip files.** Do not summarize file names instead of reading them. Treat every path in the manifest as a load instruction.
+
+### Step 4: Execute the Skill's Workflow
+
+After loading all files, follow the workflow defined in the skill file and the workflow orchestration framework:
+
+1. **Plan** — Present your plan to the user. Wait for approval before proceeding.
+2. **Clarify** — Ask the skill's clarifying questions. Do not proceed with missing information.
+3. **Execute** — Do the domain-specific work using the skill's methodology and loaded context.
+4. **Validate** — Run the skill's quality checks. If any fail, apply error recovery and re-validate.
+
+### Step 5: Deliver (If Requested)
+
+If the user wants output delivered to an external tool, read the relevant script from \`scripts/\` and follow its instructions.
+
+---
+
+## Session Management
+
+- Scope each session to one major task. Multi-task sessions degrade output quality.
+- After completing a major deliverable, recommend starting a fresh session.
+- If the conversation has gone through 3+ revision cycles, proactively suggest a session break.
+
+---
+
+## Anti-Patterns — Do Not
+
+- **Skip reading the manifest** — Always read \`manifest.yaml\` first. It is the source of truth for what files a skill needs.
+- **Acknowledge file paths without reading them** — If the manifest lists a file, read it.
+- **Skip the Plan step** — Always present a plan and wait for approval.
+- **Proceed without clarifying** — Ask the skill's questions before executing.
+- **Skip quality checks** — Run every check defined by the skill.
+- **Overload the session** — One major task per session. Recommend fresh sessions after milestones.
+`;
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): void;

package/dist/commands/status.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = status;
+const config_js_1 = require("../config.js");
+const git_js_1 = require("../git.js");
+function status() {
+    const config = (0, config_js_1.readConfig)();
+    console.log(`\n  Baseline System`);
+    console.log(`  ───────────────────────────`);
+    console.log(`  Client:       ${config.client.name}`);
+    console.log(`  Version:      v${config.version}`);
+    console.log(`  Core repo:    ${config.coreRepo}`);
+    console.log(`  Last updated: ${config.lastUpdated}`);
+    console.log(`\n  Checking for updates...`);
+    const latest = (0, git_js_1.getLatestTag)(config.coreRepo);
+    if (!latest) {
+        console.log(`  Could not determine latest version.\n`);
+        return;
+    }
+    if ((0, git_js_1.isNewer)(latest, config.version)) {
+        console.log(`  Update available: v${config.version} → v${latest}`);
+        console.log(`  Run \`baseline update\` to pull the latest.\n`);
+    }
+    else {
+        console.log(`  Up to date (v${config.version}).\n`);
+    }
+}

package/dist/commands/update.d.ts

@@ -0,0 +1 @@
+export declare function update(): void;

package/dist/commands/update.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = update;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_js_1 = require("../config.js");
+const git_js_1 = require("../git.js");
+const js_yaml_1 = require("js-yaml");
+const child_process_1 = require("child_process");
+const SYNC_DIRS = ["skills", "frameworks", "scripts", "cli"];
+function update() {
+    const config = (0, config_js_1.readConfig)();
+    const cwd = process.cwd();
+    console.log(`\n  Checking for updates...`);
+    const latest = (0, git_js_1.getLatestTag)(config.coreRepo);
+    if (!latest) {
+        console.log(`  Could not determine latest version.\n`);
+        return;
+    }
+    if (!(0, git_js_1.isNewer)(latest, config.version)) {
+        console.log(`  Already up to date (v${config.version}).\n`);
+        return;
+    }
+    console.log(`  Updating v${config.version} → v${latest}...`);
+    // Clone the latest tag to a temp directory
+    const tmpDir = (0, git_js_1.cloneAtTag)(config.coreRepo, latest);
+    // Sync each directory: full replace
+    const stats = { skills: 0, frameworks: 0, scripts: 0 };
+    for (const dir of SYNC_DIRS) {
+        const srcDir = (0, path_1.join)(tmpDir, dir);
+        const destDir = (0, path_1.join)(cwd, dir);
+        if (!(0, fs_1.existsSync)(srcDir))
+            continue;
+        // Count items for summary (skip cli in counts)
+        if (dir === "skills") {
+            stats.skills = (0, fs_1.readdirSync)(srcDir).filter((f) => (0, fs_1.statSync)((0, path_1.join)(srcDir, f)).isDirectory()).length;
+        }
+        else if (dir !== "cli") {
+            stats[dir] = (0, fs_1.readdirSync)(srcDir).filter((f) => f.endsWith(".md") || (0, fs_1.statSync)((0, path_1.join)(srcDir, f)).isDirectory()).length;
+        }
+        // Full replace
+        if ((0, fs_1.existsSync)(destDir)) {
+            (0, fs_1.rmSync)(destDir, { recursive: true });
+        }
+        (0, fs_1.cpSync)(srcDir, destDir, { recursive: true });
+    }
+    // Remove CLI source files (clients only need bin/, dist/, package.json)
+    const cliCleanup = ["src", "tsconfig.json", "package-lock.json"];
+    for (const item of cliCleanup) {
+        const p = (0, path_1.join)(cwd, "cli", item);
+        if ((0, fs_1.existsSync)(p))
+            (0, fs_1.rmSync)(p, { recursive: true });
+    }
+    // Re-install CLI dependencies after update
+    if ((0, fs_1.existsSync)((0, path_1.join)(cwd, "package.json"))) {
+        try {
+            (0, child_process_1.execSync)("npm install --silent", { cwd, stdio: "pipe" });
+        }
+        catch {
+            // Non-fatal — CLI still works from previous install
+        }
+    }
+    // Check for missing context files
+    const contextPath = config.client.contextPath || "./context";
+    checkMissingContext(tmpDir, (0, path_1.join)(cwd, contextPath));
+    // Clean up temp dir
+    (0, fs_1.rmSync)(tmpDir, { recursive: true });
+    // Update config
+    config.version = latest;
+    config.lastUpdated = new Date().toISOString();
+    (0, config_js_1.writeConfig)(config);
+    console.log(`\n  Updated v${config.version} successfully.`);
+    console.log(`  Skills: ${stats.skills} | Frameworks: ${stats.frameworks} | Scripts: ${stats.scripts}`);
+    console.log();
+}
+function checkMissingContext(coreDir, contextDir) {
+    const skillsDir = (0, path_1.join)(coreDir, "skills");
+    if (!(0, fs_1.existsSync)(skillsDir))
+        return;
+    const missingMap = new Map();
+    for (const skill of (0, fs_1.readdirSync)(skillsDir)) {
+        const manifestPath = (0, path_1.join)(skillsDir, skill, "manifest.yaml");
+        if (!(0, fs_1.existsSync)(manifestPath))
+            continue;
+        try {
+            const manifest = (0, js_yaml_1.load)((0, fs_1.readFileSync)(manifestPath, "utf-8"));
+            if (!manifest?.context?.extended)
+                continue;
+            for (const ctxPath of manifest.context.extended) {
+                const match = ctxPath.match(/context\/\{client\}\/(.+)/);
+                if (!match)
+                    continue;
+                const relPath = match[1];
+                const fullPath = (0, path_1.join)(contextDir, relPath);
+                if (!(0, fs_1.existsSync)(fullPath)) {
+                    if (!missingMap.has(relPath))
+                        missingMap.set(relPath, []);
+                    missingMap.get(relPath).push(skill);
+                }
+            }
+        }
+        catch {
+            // Skip unparseable manifests
+        }
+    }
+    if (missingMap.size > 0) {
+        console.log(`\n  Missing context files:`);
+        for (const [file, skills] of missingMap) {
+            console.log(`    → ${file} (used by ${skills.join(", ")})`);
+        }
+        console.log(`  Create these files to get the most out of these skills.`);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+export interface BaselineConfig {
+    version: string;
+    coreRepo: string;
+    lastUpdated: string;
+    client: {
+        name: string;
+        contextPath: string;
+    };
+}
+export declare function readConfig(): BaselineConfig;
+export declare function writeConfig(config: BaselineConfig): void;

package/dist/config.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const CONFIG_FILE = "baseline.config.json";
+function readConfig() {
+    const configPath = (0, path_1.join)(process.cwd(), CONFIG_FILE);
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(configPath, "utf-8"));
+    }
+    catch {
+        console.error(`Error: ${CONFIG_FILE} not found in current directory.`);
+        console.error("Run this command from your baseline system root.");
+        process.exit(1);
+    }
+}
+function writeConfig(config) {
+    const configPath = (0, path_1.join)(process.cwd(), CONFIG_FILE);
+    (0, fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n");
+}

package/dist/git.d.ts

@@ -0,0 +1,5 @@
+export declare function getLatestTag(coreRepo: string): string | null;
+export declare function fetchAndExtract(coreRepo: string, tag: string, destDir: string): void;
+/** Clone a specific tag to a temp dir and return the path */
+export declare function cloneAtTag(coreRepo: string, tag: string): string;
+export declare function isNewer(latest: string, current: string): boolean;

package/dist/git.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestTag = getLatestTag;
+exports.fetchAndExtract = fetchAndExtract;
+exports.cloneAtTag = cloneAtTag;
+exports.isNewer = isNewer;
+const child_process_1 = require("child_process");
+const semver_1 = require("semver");
+function getLatestTag(coreRepo) {
+    try {
+        const repoUrl = `https://github.com/${coreRepo}.git`;
+        const output = (0, child_process_1.execSync)(`git ls-remote --tags --sort=-v:refname ${repoUrl}`, {
+            encoding: "utf-8",
+            timeout: 15000,
+        });
+        for (const line of output.trim().split("\n")) {
+            if (!line)
+                continue;
+            const ref = line.split("\t")[1];
+            if (!ref || ref.endsWith("^{}"))
+                continue;
+            const tag = ref.replace("refs/tags/", "");
+            const version = tag.startsWith("v") ? tag.slice(1) : tag;
+            if ((0, semver_1.valid)(version))
+                return version;
+        }
+        return null;
+    }
+    catch {
+        console.error("Error: Could not reach baseline-core repo.");
+        console.error("Check your network connection and repo access.");
+        process.exit(1);
+    }
+}
+function fetchAndExtract(coreRepo, tag, destDir) {
+    const repoUrl = `https://github.com/${coreRepo}.git`;
+    const vTag = `v${tag}`;
+    (0, child_process_1.execSync)(`git archive --remote=${repoUrl} ${vTag} 2>/dev/null || git clone --depth 1 --branch ${vTag} ${repoUrl} /tmp/baseline-core-fetch`, { encoding: "utf-8", timeout: 60000, stdio: "pipe" });
+}
+/** Clone a specific tag to a temp dir and return the path */
+function cloneAtTag(coreRepo, tag) {
+    const repoUrl = `https://github.com/${coreRepo}.git`;
+    const vTag = `v${tag}`;
+    const tmpDir = `/tmp/baseline-core-${Date.now()}`;
+    (0, child_process_1.execSync)(`git clone --depth 1 --branch ${vTag} ${repoUrl} ${tmpDir}`, {
+        encoding: "utf-8",
+        timeout: 60000,
+        stdio: "pipe",
+    });
+    return tmpDir;
+}
+function isNewer(latest, current) {
+    return (0, semver_1.compare)(latest, current) > 0;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const status_js_1 = require("./commands/status.js");
+const update_js_1 = require("./commands/update.js");
+const init_js_1 = require("./commands/init.js");
+const context_js_1 = require("./commands/context.js");
+const program = new commander_1.Command();
+program
+    .name("baseline")
+    .description("Distribute and update the Baseline System")
+    .version("2.2.0");
+program
+    .command("status")
+    .description("Show current version and check for updates")
+    .action(status_js_1.status);
+program
+    .command("update")
+    .description("Pull latest skills, frameworks, and scripts from baseline-core")
+    .action(update_js_1.update);
+program
+    .command("init")
+    .description("Set up a new client system with guided onboarding")
+    .action(init_js_1.init);
+const ctxCmd = program
+    .command("context")
+    .description("Manage context files")
+    .action(() => (0, context_js_1.context)());
+ctxCmd
+    .command("add <name>")
+    .description("Create a new context file and wire it to skills")
+    .action((name) => (0, context_js_1.context)(name));
+program.parse();

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@baseline-studio/cli",
+  "version": "2.2.0",
+  "description": "CLI for distributing and updating the Baseline System — an AI-powered workflow system for product teams",
+  "keywords": [
+    "baseline",
+    "ai-system",
+    "cli",
+    "workflow",
+    "product-management",
+    "claude-code"
+  ],
+  "homepage": "https://github.com/TrentM6/baseline-core#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TrentM6/baseline-core.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/TrentM6/baseline-core/issues"
+  },
+  "license": "MIT",
+  "author": "Baseline Studio <trent@baselinestudio.design>",
+  "bin": {
+    "baseline": "./bin/baseline"
+  },
+  "files": [
+    "bin/",
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "js-yaml": "^4.1.0",
+    "semver": "^7.6.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.0",
+    "@types/node": "^20.0.0",
+    "@types/semver": "^7.5.0",
+    "typescript": "^5.4.0"
+  }
+}