@hotwired-sh/playbooks 1.0.0

package/README.md

@@ -0,0 +1,57 @@
+# @hotwired-sh/playbooks
+
+[![Hotwired](hotwired-sh.png)](https://hotwired.sh)
+
+Playbook definitions for [Hotwired](https://hotwired.sh) multi-agent workflows.
+
+## Installation
+
+```bash
+npm install @hotwired-sh/playbooks
+```
+
+## Usage
+
+### TypeScript/JavaScript
+
+```typescript
+import { loadAllPlaybooks, loadPlaybook, type Playbook } from '@hotwired-sh/playbooks';
+
+// Load all active playbooks
+const playbooks = loadAllPlaybooks();
+
+// Load a specific playbook
+const playbook = loadPlaybook('plan-build');
+```
+
+### Direct file access
+
+The playbook files are included in the package and can be accessed directly:
+
+```typescript
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const packagePath = require.resolve('@hotwired-sh/playbooks/package.json');
+// Playbooks are in ./playbooks/ relative to package root
+```
+
+## Playbook Structure
+
+Each playbook is a directory containing:
+
+- `playbook.json` - Metadata (name, roles, flow, etc.)
+- `protocol.md` - Shared protocol/rules for all agents
+- `*.md` - Role-specific prompts
+
+## Available Playbooks
+
+- **plan-build** - Planning and building features (Strategist + Builder)
+- **doc-editor** - Documentation writing and editing (Writer + Critiquer)
+
+## Creating Custom Playbooks
+
+Fork this repository and add your own playbook directories following the same structure in `./playbooks/`.
+
+## License
+
+MIT

package/dist/data.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Playbook data loader
+ */
+import type { Playbook } from './types.js';
+export declare const PLAYBOOK_IDS: readonly ["doc-editor", "plan-build"];
+export type PlaybookId = typeof PLAYBOOK_IDS[number];
+/**
+ * List all available playbook IDs (active only by default)
+ */
+export declare function listPlaybookIds(activeOnly?: boolean): string[];
+/**
+ * Load a specific playbook by ID
+ */
+export declare function loadPlaybook(playbookId: string): Playbook | null;
+/**
+ * Load all active playbooks
+ */
+export declare function loadAllPlaybooks(): Playbook[];
+//# sourceMappingURL=data.d.ts.map

package/dist/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../src/data.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,YAAY,CAAC;AAO7D,eAAO,MAAM,YAAY,uCAGf,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AAErD;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,UAAO,GAAG,MAAM,EAAE,CAe3D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAwChE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,EAAE,CAY7C"}

package/dist/data.js

@@ -0,0 +1,87 @@
+/**
+ * Playbook data loader
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Go up from dist/ to package root, then into playbooks/
+const PLAYBOOKS_DIR = join(__dirname, '..', 'playbooks');
+export const PLAYBOOK_IDS = [
+    'doc-editor',
+    'plan-build',
+];
+/**
+ * List all available playbook IDs (active only by default)
+ */
+export function listPlaybookIds(activeOnly = true) {
+    return PLAYBOOK_IDS.filter((id) => {
+        if (!activeOnly)
+            return true;
+        const metadataPath = join(PLAYBOOKS_DIR, id, 'playbook.json');
+        if (!existsSync(metadataPath))
+            return false;
+        try {
+            const content = readFileSync(metadataPath, 'utf-8');
+            const metadata = JSON.parse(content);
+            return metadata.active !== false;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Load a specific playbook by ID
+ */
+export function loadPlaybook(playbookId) {
+    const playbookDir = join(PLAYBOOKS_DIR, playbookId);
+    if (!existsSync(playbookDir)) {
+        console.error(`[playbooks] Playbook directory not found: ${playbookDir}`);
+        return null;
+    }
+    try {
+        // Load metadata
+        const metadataPath = join(playbookDir, 'playbook.json');
+        const metadataContent = readFileSync(metadataPath, 'utf-8');
+        const metadata = JSON.parse(metadataContent);
+        // Load protocol
+        const protocolPath = join(playbookDir, 'protocol.md');
+        const protocol = existsSync(protocolPath)
+            ? readFileSync(protocolPath, 'utf-8')
+            : '';
+        // Load role prompts
+        const rolePrompts = {};
+        for (const role of metadata.roles) {
+            if (role.promptFile) {
+                const promptPath = join(playbookDir, role.promptFile);
+                if (existsSync(promptPath)) {
+                    rolePrompts[role.id] = readFileSync(promptPath, 'utf-8');
+                }
+            }
+        }
+        return {
+            metadata,
+            protocol,
+            role_prompts: rolePrompts,
+        };
+    }
+    catch (error) {
+        console.error(`[playbooks] Error loading playbook: ${playbookId}`, error);
+        return null;
+    }
+}
+/**
+ * Load all active playbooks
+ */
+export function loadAllPlaybooks() {
+    const ids = listPlaybookIds();
+    const playbooks = [];
+    for (const id of ids) {
+        const playbook = loadPlaybook(id);
+        if (playbook) {
+            playbooks.push(playbook);
+        }
+    }
+    return playbooks;
+}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @hotwired-sh/playbooks
+ *
+ * Playbook definitions for Hotwired multi-agent workflows.
+ *
+ * @example Loading playbooks
+ * ```typescript
+ * import { loadAllPlaybooks, loadPlaybook } from '@hotwired-sh/playbooks';
+ *
+ * const playbooks = loadAllPlaybooks();
+ * const playbook = loadPlaybook('plan-build');
+ * ```
+ *
+ * @example Creating custom playbooks
+ * ```typescript
+ * import type { PlaybookMetadata, PlaybookRole } from '@hotwired-sh/playbooks';
+ * import { validatePlaybook } from '@hotwired-sh/playbooks';
+ *
+ * // Validate your playbook directory
+ * const result = validatePlaybook('./my-playbook');
+ * if (!result.valid) {
+ *   console.error(result.errors);
+ * }
+ * ```
+ */
+export type { Playbook, PlaybookMetadata, PlaybookRole, PlaybooksManifest, ValidationResult, } from './types.js';
+export { loadAllPlaybooks, loadPlaybook, listPlaybookIds, PLAYBOOK_IDS, type PlaybookId, } from './data.js';
+export { validatePlaybook, validateAllPlaybooks, } from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,YAAY,EACV,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,KAAK,UAAU,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * @hotwired-sh/playbooks
+ *
+ * Playbook definitions for Hotwired multi-agent workflows.
+ *
+ * @example Loading playbooks
+ * ```typescript
+ * import { loadAllPlaybooks, loadPlaybook } from '@hotwired-sh/playbooks';
+ *
+ * const playbooks = loadAllPlaybooks();
+ * const playbook = loadPlaybook('plan-build');
+ * ```
+ *
+ * @example Creating custom playbooks
+ * ```typescript
+ * import type { PlaybookMetadata, PlaybookRole } from '@hotwired-sh/playbooks';
+ * import { validatePlaybook } from '@hotwired-sh/playbooks';
+ *
+ * // Validate your playbook directory
+ * const result = validatePlaybook('./my-playbook');
+ * if (!result.valid) {
+ *   console.error(result.errors);
+ * }
+ * ```
+ */
+// Data loading
+export { loadAllPlaybooks, loadPlaybook, listPlaybookIds, PLAYBOOK_IDS, } from './data.js';
+// Validation
+export { validatePlaybook, validateAllPlaybooks, } from './validate.js';

package/dist/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Playbook type definitions
+ *
+ * These types define the structure of playbook configurations
+ * used by the Hotwired multi-agent system.
+ */
+/**
+ * Defines an agent role within a playbook
+ */
+export interface PlaybookRole {
+    /** Unique identifier for the role (kebab-case, e.g., 'test-writer') */
+    id: string;
+    /** Display name for the role (e.g., 'Test Writer') */
+    name: string;
+    /** Role type identifier (e.g., 'orchestrator', 'implementer') */
+    role: string;
+    /** Description of what this role does */
+    description: string;
+    /** Filename of the prompt markdown file (e.g., 'writer.md') */
+    promptFile: string;
+    /** Role capabilities */
+    capabilities?: {
+        canResolveImpediments?: boolean;
+    };
+}
+/**
+ * Metadata for a playbook, stored in playbook.json
+ */
+export interface PlaybookMetadata {
+    /** Unique identifier for the playbook (kebab-case, e.g., 'plan-build') */
+    id: string;
+    /** Display name for the playbook */
+    name: string;
+    /** Short tagline describing the playbook */
+    tagline: string;
+    /** Detailed description of what the playbook does */
+    description: string;
+    /** Version string */
+    version?: string;
+    /** Icon identifier (Lucide icon name) */
+    icon: string;
+    /** Whether the playbook is active and available for use (default: true) */
+    active?: boolean;
+    /** Agent roles in this playbook */
+    roles: PlaybookRole[];
+    /** Workflow phases */
+    phases?: string[];
+    /** Flow description (array of step descriptions) */
+    flow: string[];
+    /** Description of human's role in the workflow */
+    humanRole: string;
+    /** List of use cases this playbook is best suited for */
+    bestFor: string[];
+}
+/**
+ * A fully loaded playbook with all content
+ */
+export interface Playbook {
+    /** Playbook metadata from playbook.json */
+    metadata: PlaybookMetadata;
+    /** Protocol markdown content (shared rules for all agents) */
+    protocol: string;
+    /** Map of role ID to prompt markdown content */
+    role_prompts: Record<string, string>;
+}
+/**
+ * Response format for the playbooks API
+ */
+export interface PlaybooksManifest {
+    /** List of all playbooks */
+    playbooks: Playbook[];
+    /** Version timestamp for cache invalidation */
+    version: number;
+}
+/**
+ * Result of validating a playbook
+ */
+export interface ValidationResult {
+    /** Whether the playbook is valid */
+    valid: boolean;
+    /** List of validation errors (empty if valid) */
+    errors: string[];
+    /** List of validation warnings */
+    warnings: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,uEAAuE;IACvE,EAAE,EAAE,MAAM,CAAC;IACX,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,wBAAwB;IACxB,YAAY,CAAC,EAAE;QACb,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0EAA0E;IAC1E,EAAE,EAAE,MAAM,CAAC;IACX,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mCAAmC;IACnC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,sBAAsB;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,oDAAoD;IACpD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,yDAAyD;IACzD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,2CAA2C;IAC3C,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,4BAA4B;IAC5B,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oCAAoC;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,kCAAkC;IAClC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB"}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Playbook type definitions
+ *
+ * These types define the structure of playbook configurations
+ * used by the Hotwired multi-agent system.
+ */
+export {};

package/dist/validate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Playbook validation utilities
+ */
+import type { ValidationResult } from './types.js';
+/**
+ * Validate a playbook directory
+ */
+export declare function validatePlaybook(playbookDir: string): ValidationResult;
+/**
+ * Validate all playbooks in a directory
+ */
+export declare function validateAllPlaybooks(playbooksDir: string): Map<string, ValidationResult>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAErE;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB,CA4EtE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAYxF"}

package/dist/validate.js

@@ -0,0 +1,91 @@
+/**
+ * Playbook validation utilities
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Validate a playbook directory
+ */
+export function validatePlaybook(playbookDir) {
+    const errors = [];
+    const warnings = [];
+    // Check playbook.json exists
+    const metadataPath = join(playbookDir, 'playbook.json');
+    if (!existsSync(metadataPath)) {
+        errors.push('Missing playbook.json');
+        return { valid: false, errors, warnings };
+    }
+    // Parse and validate playbook.json
+    let metadata;
+    try {
+        const content = readFileSync(metadataPath, 'utf-8');
+        metadata = JSON.parse(content);
+    }
+    catch (e) {
+        errors.push(`Invalid playbook.json: ${e instanceof Error ? e.message : String(e)}`);
+        return { valid: false, errors, warnings };
+    }
+    // Required fields
+    const requiredFields = ['id', 'name', 'tagline', 'description', 'icon', 'roles', 'flow', 'humanRole', 'bestFor'];
+    for (const field of requiredFields) {
+        if (!(field in metadata)) {
+            errors.push(`Missing required field: ${field}`);
+        }
+    }
+    // Validate id format
+    if (metadata.id && !/^[a-z][a-z0-9-]*$/.test(metadata.id)) {
+        errors.push(`Invalid id format: "${metadata.id}" (must be kebab-case)`);
+    }
+    // Validate roles
+    if (Array.isArray(metadata.roles)) {
+        if (metadata.roles.length === 0) {
+            errors.push('Playbook must have at least one role');
+        }
+        const roleIds = new Set();
+        for (const role of metadata.roles) {
+            // Check for duplicate role IDs
+            if (roleIds.has(role.id)) {
+                errors.push(`Duplicate role id: "${role.id}"`);
+            }
+            roleIds.add(role.id);
+            // Check role id format
+            if (!/^[a-z][a-z0-9-]*$/.test(role.id)) {
+                errors.push(`Invalid role id format: "${role.id}" (must be kebab-case)`);
+            }
+            // Check prompt file exists
+            if (role.promptFile) {
+                const promptPath = join(playbookDir, role.promptFile);
+                if (!existsSync(promptPath)) {
+                    errors.push(`Missing prompt file for role "${role.id}": ${role.promptFile}`);
+                }
+            }
+            else {
+                errors.push(`Missing promptFile for role "${role.id}"`);
+            }
+        }
+    }
+    // Check for protocol.md (warning if missing)
+    const protocolPath = join(playbookDir, 'protocol.md');
+    if (!existsSync(protocolPath)) {
+        warnings.push('Missing protocol.md (recommended for shared agent instructions)');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate all playbooks in a directory
+ */
+export function validateAllPlaybooks(playbooksDir) {
+    const results = new Map();
+    const entries = readdirSync(playbooksDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const playbookPath = join(playbooksDir, entry.name);
+            results.set(entry.name, validatePlaybook(playbookPath));
+        }
+    }
+    return results;
+}

package/dist/validate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate.test.d.ts.map

package/dist/validate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.test.d.ts","sourceRoot":"","sources":["../src/validate.test.ts"],"names":[],"mappings":""}

package/dist/validate.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validatePlaybook, validateAllPlaybooks } from './validate.js';
+import { loadPlaybook, loadAllPlaybooks, listPlaybookIds, PLAYBOOK_IDS } from './data.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PLAYBOOKS_DIR = join(__dirname, '..', 'playbooks');
+describe('validatePlaybook', () => {
+    it('validates plan-build playbook', () => {
+        const result = validatePlaybook(join(PLAYBOOKS_DIR, 'plan-build'));
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it('validates doc-editor playbook', () => {
+        const result = validatePlaybook(join(PLAYBOOKS_DIR, 'doc-editor'));
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it('returns error for non-existent directory', () => {
+        const result = validatePlaybook(join(PLAYBOOKS_DIR, 'non-existent'));
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain('Missing playbook.json');
+    });
+});
+describe('validateAllPlaybooks', () => {
+    it('validates all playbooks in directory', () => {
+        const results = validateAllPlaybooks(PLAYBOOKS_DIR);
+        expect(results.size).toBeGreaterThan(0);
+        for (const [id, result] of results) {
+            expect(result.valid, `Playbook "${id}" should be valid`).toBe(true);
+        }
+    });
+});
+describe('loadPlaybook', () => {
+    it('loads plan-build playbook', () => {
+        const playbook = loadPlaybook('plan-build');
+        expect(playbook).not.toBeNull();
+        expect(playbook?.metadata.id).toBe('plan-build');
+        expect(playbook?.metadata.roles.length).toBeGreaterThan(0);
+        expect(playbook?.protocol).toBeTruthy();
+    });
+    it('loads doc-editor playbook', () => {
+        const playbook = loadPlaybook('doc-editor');
+        expect(playbook).not.toBeNull();
+        expect(playbook?.metadata.id).toBe('doc-editor');
+    });
+    it('returns null for non-existent playbook', () => {
+        const playbook = loadPlaybook('non-existent');
+        expect(playbook).toBeNull();
+    });
+});
+describe('loadAllPlaybooks', () => {
+    it('loads all active playbooks', () => {
+        const playbooks = loadAllPlaybooks();
+        expect(playbooks.length).toBeGreaterThan(0);
+        for (const playbook of playbooks) {
+            expect(playbook.metadata.id).toBeTruthy();
+            expect(playbook.metadata.active).not.toBe(false);
+        }
+    });
+});
+describe('listPlaybookIds', () => {
+    it('returns all playbook IDs', () => {
+        const ids = listPlaybookIds();
+        expect(ids.length).toBeGreaterThan(0);
+        expect(ids).toContain('plan-build');
+        expect(ids).toContain('doc-editor');
+    });
+});
+describe('PLAYBOOK_IDS', () => {
+    it('contains expected playbooks', () => {
+        expect(PLAYBOOK_IDS).toContain('plan-build');
+        expect(PLAYBOOK_IDS).toContain('doc-editor');
+    });
+});

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@hotwired-sh/playbooks",
+  "version": "1.0.0",
+  "description": "Playbook definitions for Hotwired multi-agent workflows",
+  "author": "Hotwired <hello@hotwired.sh>",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./schemas/playbook.schema.json": "./schemas/playbook.schema.json",
+    "./playbooks": "./playbooks",
+    "./playbooks/*": "./playbooks/*"
+  },
+  "files": [
+    "dist",
+    "playbooks",
+    "schemas"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hotwired-sh/playbooks.git"
+  },
+  "homepage": "https://hotwired.sh",
+  "bugs": {
+    "url": "https://github.com/hotwired-sh/playbooks/issues"
+  },
+  "keywords": [
+    "hotwired",
+    "playbooks",
+    "ai-agents",
+    "multi-agent",
+    "workflow"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "typecheck": "tsc --noEmit",
+    "validate": "node --loader ts-node/esm scripts/validate-playbooks.ts",
+    "prepublishOnly": "npm run build",
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.0.0",
+    "@commitlint/config-conventional": "^19.0.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/exec": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "conventional-changelog-conventionalcommits": "^7.0.2",
+    "eslint": "^8.57.0",
+    "husky": "^9.0.0",
+    "semantic-release": "^24.0.0",
+    "typescript": "^5.6.3",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}