busy-cli 0.1.2

package/dist/commands/package.js

@@ -0,0 +1,285 @@
+/**
+ * Package Management Commands
+ *
+ * Implementation of busy init, check, and package commands.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { CacheManager, deriveCachePath } from '../cache/index.js';
+import { PackageRegistry, deriveEntryId, deriveCategory } from '../registry/index.js';
+import { providerRegistry } from '../providers/index.js';
+import { isPackageManifestUrl, fetchPackageFromManifest } from '../package/manifest.js';
+// Ensure providers are registered
+import '../providers/local.js';
+import '../providers/github.js';
+import '../providers/gitlab.js';
+import '../providers/url.js';
+/**
+ * Initialize a BUSY workspace
+ */
+export async function initWorkspace(workspaceRoot) {
+    const created = [];
+    const skipped = [];
+    // Initialize package registry
+    const registry = new PackageRegistry(workspaceRoot);
+    const packagePath = path.join(workspaceRoot, 'package.busy.md');
+    const packageExists = await fs.stat(packagePath).then(() => true).catch(() => false);
+    if (packageExists) {
+        skipped.push('package.busy.md');
+    }
+    else {
+        await registry.init();
+        created.push('package.busy.md');
+    }
+    // Initialize cache manager
+    const cache = new CacheManager(workspaceRoot);
+    const librariesPath = path.join(workspaceRoot, '.libraries');
+    const librariesExists = await fs.stat(librariesPath).then(() => true).catch(() => false);
+    if (librariesExists) {
+        skipped.push('.libraries');
+    }
+    else {
+        await cache.init();
+        created.push('.libraries');
+    }
+    return {
+        workspaceRoot,
+        initialized: true,
+        created,
+        skipped,
+    };
+}
+/**
+ * Check workspace coherence
+ */
+export async function checkWorkspace(workspaceRoot, options) {
+    const errors = [];
+    const warnings = [];
+    // Load registry
+    const registry = new PackageRegistry(workspaceRoot);
+    try {
+        await registry.load();
+    }
+    catch (error) {
+        throw new Error(`Workspace not initialized: ${error instanceof Error ? error.message : error}`);
+    }
+    const cache = new CacheManager(workspaceRoot);
+    const packages = registry.getPackages();
+    // Check each package
+    for (const pkg of packages) {
+        // Check if cached file exists
+        const cachePath = pkg.cached.startsWith('.libraries/')
+            ? pkg.cached.slice('.libraries/'.length)
+            : pkg.cached;
+        const fullPath = path.join(workspaceRoot, pkg.cached);
+        const exists = await fs.stat(fullPath).then(() => true).catch(() => false);
+        if (!exists) {
+            errors.push(`Package "${pkg.id}": cached file not found at ${pkg.cached}`);
+            continue;
+        }
+        // Check integrity if specified
+        if (pkg.integrity) {
+            const isValid = await cache.verifyIntegrity(cachePath, pkg.integrity);
+            if (!isValid) {
+                warnings.push(`Package "${pkg.id}": integrity mismatch`);
+            }
+        }
+    }
+    return {
+        workspaceRoot,
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        packages: packages.length,
+    };
+}
+/**
+ * Add a package from URL
+ *
+ * If the URL points to a package.busy.md manifest, fetches the entire package.
+ * Otherwise, fetches a single file.
+ */
+export async function addPackage(workspaceRoot, url) {
+    // Check if this is a package manifest URL
+    if (isPackageManifestUrl(url)) {
+        // Use manifest-based package installation
+        const result = await fetchPackageFromManifest(workspaceRoot, url);
+        // Find provider for URL to get provider name and resolve source path
+        const provider = providerRegistry.findProvider(url);
+        const parsed = provider?.parse(url);
+        // Use absolute path for local sources, original URL for remote
+        const resolvedSource = provider?.name === 'local' && parsed
+            ? parsed.path
+            : url;
+        return {
+            id: result.name,
+            source: resolvedSource,
+            provider: provider?.name || 'url',
+            cached: result.cached,
+            version: result.version,
+            integrity: result.integrity,
+        };
+    }
+    // Single file installation (existing behavior)
+    const provider = providerRegistry.findProvider(url);
+    if (!provider) {
+        throw new Error(`No provider found for URL: ${url}`);
+    }
+    // Parse URL
+    const parsed = provider.parse(url);
+    // Derive entry ID
+    const entryId = deriveEntryId(url);
+    // Derive cache path
+    const cachePath = deriveCachePath(parsed);
+    // Fetch content
+    const content = await provider.fetch(url);
+    // Save to cache
+    const cache = new CacheManager(workspaceRoot);
+    await cache.init();
+    const saved = await cache.save(cachePath, content);
+    // Derive category
+    const category = deriveCategory(url);
+    // Create package entry
+    const entry = {
+        id: entryId,
+        description: '',
+        source: url,
+        provider: provider.name,
+        cached: `.libraries/${cachePath}`,
+        version: parsed.ref || 'latest',
+        fetched: new Date().toISOString(),
+        integrity: saved.integrity,
+        category,
+    };
+    // Load registry and add package
+    const registry = new PackageRegistry(workspaceRoot);
+    try {
+        await registry.load();
+    }
+    catch {
+        await registry.init();
+        await registry.load();
+    }
+    registry.addPackage(entry);
+    await registry.save();
+    return {
+        id: entryId,
+        source: url,
+        provider: provider.name,
+        cached: entry.cached,
+        version: entry.version,
+        integrity: saved.integrity,
+    };
+}
+/**
+ * Remove a package
+ */
+export async function removePackage(workspaceRoot, packageId) {
+    // Load registry
+    const registry = new PackageRegistry(workspaceRoot);
+    await registry.load();
+    // Get package info before removing
+    const pkg = registry.getPackage(packageId);
+    if (!pkg) {
+        return { id: packageId, removed: false };
+    }
+    // Remove from registry
+    registry.removePackage(packageId);
+    await registry.save();
+    // Remove cached file
+    const cache = new CacheManager(workspaceRoot);
+    const cachePath = pkg.cached.startsWith('.libraries/')
+        ? pkg.cached.slice('.libraries/'.length)
+        : pkg.cached;
+    await cache.delete(cachePath);
+    return { id: packageId, removed: true };
+}
+/**
+ * List all packages
+ */
+export async function listPackages(workspaceRoot) {
+    // Load registry
+    const registry = new PackageRegistry(workspaceRoot);
+    await registry.load();
+    const packages = registry.getPackages();
+    return { packages };
+}
+/**
+ * Get package info
+ */
+export async function getPackageInfo(workspaceRoot, packageId) {
+    // Load registry
+    const registry = new PackageRegistry(workspaceRoot);
+    await registry.load();
+    return registry.getPackage(packageId) || null;
+}
+/**
+ * Upgrade a package to latest version
+ */
+export async function upgradePackage(workspaceRoot, packageId) {
+    // Load registry
+    const registry = new PackageRegistry(workspaceRoot);
+    await registry.load();
+    // Get current package
+    const pkg = registry.getPackage(packageId);
+    if (!pkg) {
+        throw new Error(`Package not found: ${packageId}`);
+    }
+    // Find provider
+    const provider = providerRegistry.findProvider(pkg.source);
+    if (!provider) {
+        throw new Error(`No provider found for package source: ${pkg.source}`);
+    }
+    // Parse current URL
+    const parsed = provider.parse(pkg.source);
+    // Get latest version
+    let latestVersion;
+    try {
+        if (provider.getLatestVersion) {
+            latestVersion = await provider.getLatestVersion(parsed);
+        }
+        else {
+            throw new Error('Provider does not support version resolution');
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to get latest version: ${error instanceof Error ? error.message : error}`);
+    }
+    const oldVersion = pkg.version;
+    // Check if already at latest
+    if (latestVersion === oldVersion) {
+        return {
+            id: packageId,
+            upgraded: false,
+            oldVersion,
+            newVersion: latestVersion,
+        };
+    }
+    // Build new URL with latest version
+    const newUrl = pkg.source.replace(oldVersion, latestVersion);
+    // Fetch new content
+    const content = await provider.fetch(newUrl);
+    // Save to cache
+    const cache = new CacheManager(workspaceRoot);
+    const cachePath = pkg.cached.startsWith('.libraries/')
+        ? pkg.cached.slice('.libraries/'.length)
+        : pkg.cached;
+    const saved = await cache.save(cachePath, content);
+    // Update package entry
+    const updatedEntry = {
+        ...pkg,
+        source: newUrl,
+        version: latestVersion,
+        fetched: new Date().toISOString(),
+        integrity: saved.integrity,
+    };
+    registry.addPackage(updatedEntry);
+    await registry.save();
+    return {
+        id: packageId,
+        upgraded: true,
+        oldVersion,
+        newVersion: latestVersion,
+    };
+}
+//# sourceMappingURL=package.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { loadRepo } from './loader.js';
+export { buildContext, writeContext, get, parentsOf, childrenOf, getConceptContext } from './builders/context.js';
+export { mergeRepos, extendRepo, loadRepoFromJSON } from './merge.js';
+export type { DocId, Slug, Section, ConceptBase, BusyDocument, LocalDef, Operation, ImportDef, EdgeRole, Edge, File, Repo, ContextPayload, FrontMatter, } from './types/schema.js';
+export type { BuildOpts, ConceptContext } from './builders/context.js';
+export { DocIdSchema, SlugSchema, SectionIdSchema, ConceptIdSchema, SectionSchema, ConceptBaseSchema, LocalDefSchema, SetupSchema, OperationSchema, ImportDefSchema, BusyDocumentSchema, PlaybookSchema, EdgeRoleSchema, EdgeSchema, FileSchema, RepoSchema, ContextPayloadSchema, FrontMatterSchema, } from './types/schema.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":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,GAAG,EAAE,SAAS,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAClH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGtE,YAAY,EACV,KAAK,EACL,IAAI,EACJ,OAAO,EACP,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,cAAc,EACd,WAAW,GACZ,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EACL,WAAW,EACX,UAAU,EACV,eAAe,EACf,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,EACV,UAAU,EACV,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// Main exports
+export { loadRepo } from './loader.js';
+export { buildContext, writeContext, get, parentsOf, childrenOf, getConceptContext } from './builders/context.js';
+export { mergeRepos, extendRepo, loadRepoFromJSON } from './merge.js';
+// Zod Schema exports for validation in other repos
+export { DocIdSchema, SlugSchema, SectionIdSchema, ConceptIdSchema, SectionSchema, ConceptBaseSchema, LocalDefSchema, SetupSchema, OperationSchema, ImportDefSchema, BusyDocumentSchema, PlaybookSchema, EdgeRoleSchema, EdgeSchema, FileSchema, RepoSchema, ContextPayloadSchema, FrontMatterSchema, } from './types/schema.js';
+//# sourceMappingURL=index.js.map

package/dist/loader.d.ts

@@ -0,0 +1,6 @@
+import { Repo } from './types/schema.js';
+/**
+ * Load and index a workspace from glob patterns
+ */
+export declare function loadRepo(globs: string[]): Promise<Repo>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,IAAI,EAUL,MAAM,mBAAmB,CAAC;AAS3B;;GAEG;AACH,wBAAsB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA+T7D"}

package/dist/loader.js

@@ -0,0 +1,361 @@
+import { readFile } from 'fs/promises';
+import fg from 'fast-glob';
+import path from 'path';
+import { parseFrontMatter } from './parsers/frontmatter.js';
+import { parseSections, getAllSections, findSection } from './parsers/sections.js';
+import { extractLocalDefs } from './parsers/localdefs.js';
+import { extractOperations } from './parsers/operations.js';
+import { extractImports, legacyResolveImportTarget } from './parsers/imports.js';
+import { extractLinksFromSection } from './parsers/links.js';
+import { debug, warn } from './utils/logger.js';
+/**
+ * Load and index a workspace from glob patterns
+ */
+export async function loadRepo(globs) {
+    debug.parser('Loading repo from globs: %o', globs);
+    // Find all markdown files
+    const filePaths = await fg(globs, {
+        absolute: true,
+        onlyFiles: true,
+    });
+    debug.parser('Found %d files', filePaths.length);
+    // Sort files for determinism
+    filePaths.sort();
+    // Build file map for resolution
+    const fileMap = new Map();
+    // First pass: parse frontmatter to build file map
+    const fileContents = new Map();
+    for (const filePath of filePaths) {
+        const content = await readFile(filePath, 'utf-8');
+        fileContents.set(filePath, content);
+        const { docId } = parseFrontMatter(content, filePath);
+        // Store multiple variants for resolution:
+        // - Full basename: "document.busy.md"
+        // - Without .busy: "document.md" (for imports that reference old extension)
+        // - Just name: "document"
+        const basename = path.basename(filePath);
+        const withoutBusy = basename.replace('.busy.md', '.md');
+        const nameOnly = basename.replace(/\.busy\.md$/, '').replace(/\.md$/, '');
+        fileMap.set(basename, { docId, path: filePath });
+        if (withoutBusy !== basename) {
+            fileMap.set(withoutBusy, { docId, path: filePath });
+        }
+        fileMap.set(nameOnly, { docId, path: filePath });
+    }
+    // Second pass: parse documents
+    const files = []; // Lightweight file representations
+    const docs = []; // Full concept definitions
+    const allLocaldefs = new Map();
+    const allOperations = new Map();
+    const allImports = [];
+    const allEdges = [];
+    const allSections = new Map();
+    // Store document parts temporarily before building final docs
+    const docParts = new Map();
+    for (const filePath of filePaths) {
+        const content = fileContents.get(filePath);
+        // Parse frontmatter
+        const { frontmatter, content: mdContent, docId, kind, types, extends: extends_ } = parseFrontMatter(content, filePath);
+        // Parse sections
+        const sections = parseSections(mdContent, docId, filePath);
+        // Create file representation (lightweight - just sections)
+        files.push({
+            docId,
+            path: filePath,
+            name: frontmatter.Name,
+            sections,
+        });
+        // Index all sections
+        for (const section of getAllSections(sections)) {
+            allSections.set(section.id, section);
+        }
+        // Extract local definitions
+        const localdefs = extractLocalDefs(sections, docId, filePath);
+        for (const localdef of localdefs) {
+            allLocaldefs.set(localdef.id, localdef);
+        }
+        // Extract operations
+        const operations = extractOperations(sections, docId, filePath);
+        for (const operation of operations) {
+            allOperations.set(operation.id, operation);
+        }
+        // Extract setup (if present)
+        const setupSection = findSection(sections, 'setup');
+        const setup = setupSection ? {
+            kind: 'setup',
+            id: `${docId}::setup`, // Use :: for concept IDs
+            docId,
+            slug: 'setup',
+            name: 'Setup',
+            content: setupSection.content,
+            types: [],
+            extends: [],
+            sectionRef: setupSection.id, // sectionRef uses # for section references
+        } : undefined;
+        // Extract imports
+        const { imports, symbols } = extractImports(content, docId);
+        // Store document parts
+        docParts.set(docId, {
+            filePath,
+            content,
+            frontmatter,
+            docId,
+            types,
+            extends: extends_,
+            sections,
+            localdefs,
+            operations,
+            setup,
+            imports,
+            symbols,
+        });
+        // Resolve imports
+        for (const importDef of imports) {
+            const resolved = legacyResolveImportTarget(importDef.target, docId, fileMap);
+            // Store resolved as ConceptId (string) per schema
+            if (resolved.docId) {
+                const resolvedId = resolved.slug
+                    ? `${resolved.docId}#${resolved.slug}`
+                    : resolved.docId;
+                importDef.resolved = resolvedId;
+                // Create import edge
+                allEdges.push({
+                    from: docId,
+                    to: resolvedId,
+                    role: 'imports',
+                });
+            }
+            // Update symbol table (keeps object format for easy lookup)
+            if (symbols[importDef.label]) {
+                symbols[importDef.label] = resolved;
+            }
+            allImports.push(importDef);
+        }
+        // Extract links and create edges
+        for (const section of getAllSections(sections)) {
+            const linkEdges = extractLinksFromSection(section, section.content, symbols, fileMap);
+            allEdges.push(...linkEdges);
+        }
+        // Create extends edges for local definitions
+        for (const localdef of localdefs) {
+            for (const parent of localdef.extends) {
+                const resolvedParent = resolveSymbol(parent, docId, allLocaldefs, docs, symbols);
+                if (resolvedParent) {
+                    allEdges.push({
+                        from: localdef.id,
+                        to: resolvedParent,
+                        role: 'extends',
+                    });
+                }
+                else {
+                    warn(`Unresolved extends: ${parent} in ${localdef.id}`);
+                }
+            }
+        }
+    }
+    // Build final document structures with inline arrays
+    for (const [docId, parts] of docParts) {
+        const isPlaybook = parts.types.some((t) => t.toLowerCase() === 'playbook');
+        if (isPlaybook) {
+            // Extract sequence from ExecutePlaybook operation
+            const sequence = extractPlaybookSequence(parts.sections);
+            const doc = {
+                kind: 'playbook',
+                id: parts.docId,
+                docId: parts.docId,
+                slug: parts.docId.toLowerCase(),
+                name: parts.frontmatter.Name,
+                content: parts.content,
+                types: parts.types,
+                extends: parts.extends,
+                sectionRef: `${parts.docId}#`, // Root reference
+                imports: parts.imports,
+                localdefs: parts.localdefs,
+                setup: parts.setup,
+                operations: parts.operations,
+                sequence,
+            };
+            docs.push(doc);
+        }
+        else {
+            const doc = {
+                kind: 'document',
+                id: parts.docId,
+                docId: parts.docId,
+                slug: parts.docId.toLowerCase(),
+                name: parts.frontmatter.Name,
+                content: parts.content,
+                types: parts.types,
+                extends: parts.extends,
+                sectionRef: `${parts.docId}#`, // Root reference
+                imports: parts.imports,
+                localdefs: parts.localdefs,
+                setup: parts.setup,
+                operations: parts.operations,
+            };
+            docs.push(doc);
+        }
+    }
+    // Inherit operations from parent documents
+    inheritOperations(docs, allOperations);
+    // Build concepts array (includes all documents as ConceptBase)
+    const concepts = docs.map((doc) => ({
+        kind: doc.kind,
+        id: doc.id,
+        docId: doc.docId,
+        slug: doc.slug,
+        name: doc.name,
+        content: doc.content,
+        types: doc.types,
+        extends: doc.extends,
+        sectionRef: doc.sectionRef,
+        children: [], // ConceptBase has children for hierarchy
+    }));
+    // Build byId index
+    const byId = {};
+    for (const concept of concepts) {
+        byId[concept.id] = concept;
+    }
+    for (const [id, section] of allSections) {
+        byId[id] = section;
+    }
+    for (const [id, localdef] of allLocaldefs) {
+        byId[id] = localdef;
+    }
+    for (const [id, operation] of allOperations) {
+        byId[id] = operation;
+    }
+    // Reclassify edges based on target type
+    // Links to operations should be 'calls', links to defs/concepts should be 'ref'
+    for (const edge of allEdges) {
+        if (edge.role === 'ref') {
+            const target = byId[edge.to];
+            if (target && target.kind === 'operation') {
+                edge.role = 'calls';
+            }
+        }
+    }
+    // Build byFile index
+    const byFile = {};
+    for (const doc of docs) {
+        const bySlug = {};
+        const parts = docParts.get(doc.docId);
+        if (parts) {
+            for (const section of getAllSections(parts.sections)) {
+                bySlug[section.slug] = section;
+            }
+        }
+        byFile[doc.docId] = { concept: doc, bySlug };
+    }
+    const repo = {
+        files,
+        concepts,
+        localdefs: Object.fromEntries(allLocaldefs),
+        operations: Object.fromEntries(allOperations),
+        imports: allImports,
+        byId,
+        byFile,
+        edges: allEdges,
+    };
+    debug.parser('Loaded repo: %d docs, %d concepts, %d localdefs, %d operations, %d imports, %d edges', docs.length, concepts.length, allLocaldefs.size, allOperations.size, allImports.length, allEdges.length);
+    return repo;
+}
+/**
+ * Inherit operations from parent documents
+ * Inherits from:
+ * 1. Documents in the 'extends' array (explicit extension)
+ * 2. Documents in the 'types' array (implicit type-based inheritance)
+ */
+function inheritOperations(docs, allOperations) {
+    // Build doc lookup by name
+    const docByName = new Map();
+    for (const doc of docs) {
+        docByName.set(doc.name, doc);
+    }
+    // Process each document
+    for (const doc of docs) {
+        // Collect parent names from both extends and types
+        const parentNames = [...doc.extends, ...doc.types];
+        if (parentNames.length === 0)
+            continue;
+        // Get operations currently in this document
+        const existingOps = new Set();
+        for (const [id, op] of allOperations) {
+            if (op.docId === doc.docId) {
+                existingOps.add(op.slug);
+            }
+        }
+        // Inherit from parent documents
+        for (const parentName of parentNames) {
+            const parentDoc = docByName.get(parentName);
+            if (!parentDoc) {
+                debug.parser('Parent document not found: %s', parentName);
+                continue;
+            }
+            // Find all operations in parent document
+            for (const [id, op] of allOperations) {
+                if (op.docId === parentDoc.docId) {
+                    // If operation not overridden in child, inherit it
+                    if (!existingOps.has(op.slug)) {
+                        const inheritedOp = {
+                            ...op,
+                            id: `${doc.docId}::${op.slug}`, // Use :: for concept IDs
+                            docId: doc.docId,
+                        };
+                        allOperations.set(inheritedOp.id, inheritedOp);
+                        existingOps.add(op.slug);
+                        debug.parser('Inherited operation %s from %s to %s', op.name, parentDoc.name, doc.name);
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Resolve a symbol (name or label) to a node ID
+ */
+function resolveSymbol(nameOrLabel, currentDocId, localdefs, docs, symbols) {
+    // 1. Check for LocalDef in same doc
+    const localdefId = `${currentDocId}::${nameOrLabel.toLowerCase()}`;
+    if (localdefs.has(localdefId)) {
+        return localdefId;
+    }
+    // 2. Check for Concept/Doc by Name
+    const doc = docs.find((d) => d.name === nameOrLabel);
+    if (doc) {
+        return doc.docId;
+    }
+    // 3. Check import symbol table
+    const symbol = symbols[nameOrLabel];
+    if (symbol?.docId) {
+        return symbol.slug ? `${symbol.docId}#${symbol.slug}` : symbol.docId;
+    }
+    return undefined;
+}
+/**
+ * Extract sequence of operations from a playbook's ExecutePlaybook operation
+ * Looks for sections with "Step" in the title and extracts Target metadata
+ */
+function extractPlaybookSequence(sections) {
+    const sequence = [];
+    // Find ExecutePlaybook operation in the Operations section
+    const allSecs = getAllSections(sections);
+    const executePlaybook = allSecs.find((sec) => sec.title.toLowerCase() === 'executeplaybook');
+    if (!executePlaybook) {
+        return sequence;
+    }
+    // Look for child sections that are steps (contain "step" in title, case-insensitive)
+    for (const child of executePlaybook.children) {
+        if (child.title.toLowerCase().includes('step')) {
+            // Extract Target field from content
+            // Pattern: - **Target:** `OperationName`
+            const targetMatch = child.content.match(/^\s*-\s*\*\*Target:\*\*\s*`([^`]+)`/m);
+            if (targetMatch) {
+                sequence.push(targetMatch[1]);
+                debug.parser('Found playbook sequence step: %s -> %s', child.title, targetMatch[1]);
+            }
+        }
+    }
+    return sequence;
+}
+//# sourceMappingURL=loader.js.map

package/dist/merge.d.ts

@@ -0,0 +1,16 @@
+import { Repo } from './types/schema.js';
+/**
+ * Merge multiple repos into a single repo
+ * Later repos override earlier ones when there are conflicts
+ */
+export declare function mergeRepos(...repos: Repo[]): Repo;
+/**
+ * Extend a base repo with additional files
+ * This is a convenience wrapper around mergeRepos
+ */
+export declare function extendRepo(baseRepo: Repo, extensionRepo: Repo): Repo;
+/**
+ * Load a repo from JSON and validate it against the schema
+ */
+export declare function loadRepoFromJSON(json: string): Repo;
+//# sourceMappingURL=merge.d.ts.map