opentasks 0.0.1 → 0.0.2

package/dist/providers/beads.js

@@ -0,0 +1,865 @@
+/**
+ * Beads Provider
+ *
+ * Provider that integrates with Beads via CLI.
+ * Handles beads:// and bd:// URI schemes.
+ */
+import { exec as execCallback } from 'child_process';
+import { promisify } from 'util';
+import chokidar from 'chokidar';
+import { ProviderError as ProviderErrorClass } from './types.js';
+import { filterEdgesByType, filterEdgesByDirection } from './traits/RelationshipQueryable.js';
+const execAsync = promisify(execCallback);
+// ============================================================================
+// Constants
+// ============================================================================
+/**
+ * Pattern for beads:// or bd:// URIs
+ * Format: beads://[workspace/]id or bd://[workspace/]id
+ */
+const BEADS_URI_PATTERN = /^(beads|bd):\/\/(?:([^/]+)\/)?(.+)$/i;
+/**
+ * Pattern for Beads issue IDs
+ */
+const BEADS_ID_PATTERN = /^bd-[a-z0-9]+$/i;
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Map Beads priority to normalized 0-4 scale
+ */
+function mapPriority(priority) {
+    if (priority === undefined)
+        return undefined;
+    if (typeof priority === 'number') {
+        // Assume already 0-4 scale
+        return Math.max(0, Math.min(4, priority));
+    }
+    // Map string priorities
+    switch (priority.toLowerCase()) {
+        case 'critical':
+        case 'highest':
+            return 0;
+        case 'high':
+            return 1;
+        case 'medium':
+        case 'normal':
+            return 2;
+        case 'low':
+            return 3;
+        case 'lowest':
+            return 4;
+        default:
+            return 2;
+    }
+}
+/**
+ * Valid task actions for each status state
+ */
+function validActionsForStatus(status) {
+    switch (status) {
+        case 'open':
+            return ['start', 'block', 'close'];
+        case 'in_progress':
+            return ['complete', 'block', 'close'];
+        case 'blocked':
+            return ['reopen', 'close'];
+        case 'closed':
+            return ['reopen'];
+        default:
+            return ['start', 'complete', 'block', 'reopen', 'close'];
+    }
+}
+/**
+ * Convert Beads issue to ProviderNode
+ */
+function beadsIssueToProviderNode(issue, workspace = '.') {
+    return {
+        id: issue.id,
+        uri: `beads://${workspace}/${issue.id}`,
+        type: 'issue',
+        title: issue.title,
+        content: issue.description,
+        status: issue.status,
+        priority: mapPriority(issue.priority),
+        rawData: issue,
+        fetchedAt: new Date().toISOString(),
+    };
+}
+// ============================================================================
+// Beads Provider Implementation
+// ============================================================================
+/**
+ * Create a Beads provider with relationship querying and optional watching support
+ */
+export function createBeadsProvider(config = {}) {
+    const executable = config.executable ?? 'bd';
+    const cwd = config.cwd;
+    const timeout = config.timeout ?? 30000;
+    const extraArgs = config.extraArgs ?? [];
+    const watchPath = config.watchPath;
+    const watchDebounceMs = config.watchDebounceMs ?? 200;
+    const capabilities = {
+        read: true,
+        write: true,
+        search: true,
+        watch: !!watchPath,
+        mount: true,
+        feedback: false,
+    };
+    // =========================================================================
+    // Watch State (only active when watchPath is configured)
+    // =========================================================================
+    /** Cached content hashes for change diffing: beads issue id → hash of serialized data */
+    const cachedHashes = new Map();
+    /** Cached edge signatures for edge change detection: "from:to:type" → true */
+    const cachedEdgeKeys = new Set();
+    /** chokidar watcher instance */
+    let fileWatcher = null;
+    /** Current watch callback */
+    let watchCallback = null;
+    /** Debounce timer for coalescing rapid file changes */
+    let debounceTimer = null;
+    /**
+     * Simple hash for diffing (not cryptographic — just for detecting changes).
+     * Uses the same approach as sync.ts calculateContentHash.
+     */
+    function quickHash(input) {
+        let hash = 0;
+        for (let i = 0; i < input.length; i++) {
+            const char = input.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return hash.toString(16);
+    }
+    /**
+     * Build a stable hash key for a Beads issue (substantive fields only)
+     */
+    function issueHashKey(issue) {
+        const substantive = {
+            title: issue.title,
+            description: issue.description,
+            status: issue.status,
+            priority: issue.priority,
+            tags: issue.tags ? [...issue.tags].sort() : undefined,
+            blocks: issue.blocks ? [...issue.blocks].sort() : undefined,
+            blockedBy: issue.blockedBy ? [...issue.blockedBy].sort() : undefined,
+            // Structured format (bd v0.49+)
+            dependency_count: issue.dependency_count,
+            dependent_count: issue.dependent_count,
+            parent: issue.parent,
+            children: issue.children ? [...issue.children].sort() : undefined,
+        };
+        return quickHash(JSON.stringify(substantive));
+    }
+    /**
+     * Compute the set of edge keys from an issue's relationship fields
+     */
+    function issueEdgeKeys(issue) {
+        const keys = new Set();
+        // Legacy format: blocks/blockedBy string arrays
+        if (issue.blocks) {
+            for (const id of issue.blocks)
+                keys.add(`${issue.id}:${id}:blocks`);
+        }
+        if (issue.blockedBy) {
+            for (const id of issue.blockedBy)
+                keys.add(`${id}:${issue.id}:blocks`);
+        }
+        // Structured format (bd v0.49+): dependencies array with {issue_id, depends_on_id, type}
+        if (issue.dependencies) {
+            for (const dep of issue.dependencies) {
+                // dep.depends_on_id blocks dep.issue_id
+                keys.add(`${dep.depends_on_id}:${dep.issue_id}:blocks`);
+            }
+        }
+        if (issue.parent) {
+            keys.add(`${issue.parent}:${issue.id}:parent-child`);
+        }
+        if (issue.children) {
+            for (const id of issue.children)
+                keys.add(`${issue.id}:${id}:parent-child`);
+        }
+        return keys;
+    }
+    /**
+     * Diff current Beads state against cached hashes and emit change events.
+     * Called when file watcher detects a change.
+     */
+    async function diffAndEmit() {
+        if (!watchCallback)
+            return;
+        try {
+            const output = await execBd(['list', '--json']);
+            const issues = parseJson(output);
+            const currentIds = new Set();
+            const currentEdgeKeys = new Set();
+            for (const issue of issues) {
+                // Beads uses "tombstone" status for soft-deleted issues — treat as deleted
+                const isTombstone = issue.status === 'tombstone';
+                if (isTombstone) {
+                    // Only emit 'deleted' if we previously knew about this issue
+                    if (cachedHashes.has(issue.id)) {
+                        watchCallback({
+                            kind: 'node',
+                            event: {
+                                type: 'deleted',
+                                nodeId: issue.id,
+                                uri: `beads://./${issue.id}`,
+                                timestamp: new Date().toISOString(),
+                            },
+                        });
+                        cachedHashes.delete(issue.id);
+                    }
+                    continue;
+                }
+                currentIds.add(issue.id);
+                const hash = issueHashKey(issue);
+                const prevHash = cachedHashes.get(issue.id);
+                const providerNode = beadsIssueToProviderNode(issue);
+                if (!prevHash) {
+                    // New issue
+                    watchCallback({
+                        kind: 'node',
+                        event: {
+                            type: 'created',
+                            nodeId: issue.id,
+                            uri: providerNode.uri,
+                            node: providerNode,
+                            timestamp: new Date().toISOString(),
+                        },
+                    });
+                }
+                else if (prevHash !== hash) {
+                    // Changed issue — compute changed fields if possible
+                    const event = {
+                        type: 'updated',
+                        nodeId: issue.id,
+                        uri: providerNode.uri,
+                        node: providerNode,
+                        timestamp: new Date().toISOString(),
+                    };
+                    // We can report changed fields by comparing against cached data
+                    // but we only store hashes, not full data. For field-level we'd
+                    // need to cache full issue objects. For now, we report the node
+                    // change without field detail — consumers can diff themselves.
+                    watchCallback({ kind: 'node', event });
+                }
+                cachedHashes.set(issue.id, hash);
+                // Collect current edges
+                for (const key of issueEdgeKeys(issue)) {
+                    currentEdgeKeys.add(key);
+                }
+            }
+            // Detect deleted issues
+            for (const [id] of cachedHashes) {
+                if (!currentIds.has(id)) {
+                    watchCallback({
+                        kind: 'node',
+                        event: {
+                            type: 'deleted',
+                            nodeId: id,
+                            uri: `beads://./${id}`,
+                            timestamp: new Date().toISOString(),
+                        },
+                    });
+                    cachedHashes.delete(id);
+                }
+            }
+            // Detect edge changes
+            // New edges
+            for (const key of currentEdgeKeys) {
+                if (!cachedEdgeKeys.has(key)) {
+                    const [from, to, type] = key.split(':');
+                    const event = {
+                        type: 'created',
+                        edge: { from, to, type },
+                        sourceUri: `beads://./${from}`,
+                        targetUri: `beads://./${to}`,
+                        timestamp: new Date().toISOString(),
+                    };
+                    watchCallback({ kind: 'edge', event });
+                }
+            }
+            // Deleted edges
+            for (const key of cachedEdgeKeys) {
+                if (!currentEdgeKeys.has(key)) {
+                    const [from, to, type] = key.split(':');
+                    const event = {
+                        type: 'deleted',
+                        edge: { from, to, type },
+                        sourceUri: `beads://./${from}`,
+                        targetUri: `beads://./${to}`,
+                        timestamp: new Date().toISOString(),
+                    };
+                    watchCallback({ kind: 'edge', event });
+                }
+            }
+            // Update cached edge state
+            cachedEdgeKeys.clear();
+            for (const key of currentEdgeKeys) {
+                cachedEdgeKeys.add(key);
+            }
+        }
+        catch {
+            // Resilient — log internally but don't crash the watcher
+        }
+    }
+    /**
+     * Handle a raw file change event with debouncing
+     */
+    function onFileChange() {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(() => {
+            debounceTimer = null;
+            void diffAndEmit();
+        }, watchDebounceMs);
+    }
+    /**
+     * Seed the cached hashes from current Beads state (so the first
+     * diff only emits genuine changes, not the entire existing dataset)
+     */
+    async function seedCache() {
+        try {
+            const output = await execBd(['list', '--json']);
+            const issues = parseJson(output);
+            cachedHashes.clear();
+            cachedEdgeKeys.clear();
+            for (const issue of issues) {
+                // Skip tombstoned (deleted) issues when seeding cache
+                if (issue.status === 'tombstone')
+                    continue;
+                cachedHashes.set(issue.id, issueHashKey(issue));
+                for (const key of issueEdgeKeys(issue)) {
+                    cachedEdgeKeys.add(key);
+                }
+            }
+        }
+        catch {
+            // If we can't seed, first diff will treat everything as 'created'
+        }
+    }
+    /**
+     * Shell-escape a single argument
+     */
+    function shellEscape(arg) {
+        // If arg contains spaces, quotes, or special shell chars, wrap in single quotes
+        // and escape any existing single quotes
+        if (/['\s"\\$`!]/.test(arg)) {
+            return `'${arg.replace(/'/g, "'\\''")}'`;
+        }
+        return arg;
+    }
+    /**
+     * Execute a bd CLI command
+     * @param args - Command arguments
+     * @param context - Optional operational context for per-call overrides (cwd, timeout)
+     */
+    async function execBd(args, context) {
+        const command = [executable, ...extraArgs, ...args.map(shellEscape)].join(' ');
+        try {
+            const { stdout } = await execAsync(command, {
+                cwd: context?.cwd ?? cwd,
+                timeout: context?.timeout ?? timeout,
+                env: { ...process.env },
+            });
+            return stdout.trim();
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                throw new ProviderErrorClass('PROVIDER_ERROR', `Beads CLI not found: ${executable}`, 'beads');
+            }
+            if (err.killed) {
+                throw new ProviderErrorClass('TIMEOUT', `Command timed out: ${command}`, 'beads');
+            }
+            // Extract error details from stdout if available (bd returns JSON errors)
+            let errorMessage = err.message ?? 'Unknown error';
+            if (err.stdout) {
+                try {
+                    const parsed = JSON.parse(err.stdout);
+                    if (parsed.error) {
+                        errorMessage = parsed.error;
+                    }
+                }
+                catch {
+                    // Not JSON, use stdout as-is if it has content
+                    if (err.stdout.trim()) {
+                        errorMessage = err.stdout.trim();
+                    }
+                }
+            }
+            throw new ProviderErrorClass('OPERATION_FAILED', `Beads CLI error: ${errorMessage}`, 'beads', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Parse JSON output from bd CLI
+     */
+    function parseJson(output) {
+        try {
+            return JSON.parse(output);
+        }
+        catch {
+            throw new ProviderErrorClass('PROVIDER_ERROR', 'Failed to parse Beads CLI output as JSON', 'beads');
+        }
+    }
+    return {
+        name: 'beads',
+        schemes: ['beads', 'bd'],
+        capabilities,
+        // =========================================================================
+        // URI Operations
+        // =========================================================================
+        parseUri(uri) {
+            // Check for beads:// or bd:// URI
+            const match = uri.match(BEADS_URI_PATTERN);
+            if (match) {
+                const scheme = match[1].toLowerCase();
+                const workspace = match[2] || '.';
+                const id = match[3];
+                return {
+                    scheme,
+                    workspace,
+                    id,
+                    isRelative: workspace === '.',
+                };
+            }
+            // Check for bare Beads ID
+            if (BEADS_ID_PATTERN.test(uri)) {
+                return {
+                    scheme: 'beads',
+                    workspace: '.',
+                    id: uri,
+                    isRelative: true,
+                };
+            }
+            return null;
+        },
+        buildUri(id, options) {
+            const workspace = options?.workspace ?? '.';
+            if (options?.relative) {
+                return id;
+            }
+            return `beads://${workspace}/${id}`;
+        },
+        isValidUri(uri) {
+            return this.parseUri(uri) !== null;
+        },
+        // =========================================================================
+        // CRUD Operations
+        // =========================================================================
+        async get(id, context) {
+            // Parse URI if full URI is passed
+            const parsed = this.parseUri(id);
+            const issueId = parsed?.id ?? id;
+            const workspace = parsed?.workspace ?? '.';
+            try {
+                const output = await execBd(['show', issueId, '--json'], context);
+                // bd show returns an array, take the first element
+                const issues = parseJson(output);
+                if (!issues || issues.length === 0) {
+                    return null;
+                }
+                // Treat tombstoned (soft-deleted) issues as not found
+                if (issues[0].status === 'tombstone') {
+                    return null;
+                }
+                return beadsIssueToProviderNode(issues[0], workspace);
+            }
+            catch (error) {
+                // Return null for not found, re-throw other errors
+                if (error instanceof ProviderErrorClass && error.code === 'OPERATION_FAILED') {
+                    const message = error.message.toLowerCase();
+                    if (message.includes('not found') ||
+                        message.includes('does not exist') ||
+                        message.includes('no issue found matching')) {
+                        return null;
+                    }
+                }
+                throw error;
+            }
+        },
+        async list(filter, context) {
+            const args = ['list', '--json'];
+            // Add filters if supported by bd CLI
+            if (filter?.status) {
+                args.push('--status', filter.status);
+            }
+            if (filter?.limit) {
+                args.push('--limit', String(filter.limit));
+            }
+            const output = await execBd(args, context);
+            const issues = parseJson(output);
+            return issues
+                .filter((issue) => issue.status !== 'tombstone')
+                .map((issue) => beadsIssueToProviderNode(issue));
+        },
+        async create(input, context) {
+            const args = ['create', input.title];
+            if (input.content) {
+                args.push('--description', input.content);
+            }
+            if (input.status) {
+                args.push('--status', input.status);
+            }
+            if (input.priority !== undefined) {
+                args.push('--priority', String(input.priority));
+            }
+            args.push('--json');
+            const output = await execBd(args, context);
+            const issue = parseJson(output);
+            return beadsIssueToProviderNode(issue);
+        },
+        async update(id, updates, context) {
+            // Parse URI if full URI is passed
+            const parsed = this.parseUri(id);
+            const issueId = parsed?.id ?? id;
+            const args = ['update', issueId];
+            if (updates.title) {
+                args.push('--title', updates.title);
+            }
+            if (updates.content) {
+                args.push('--description', updates.content);
+            }
+            if (updates.status) {
+                args.push('--status', updates.status);
+            }
+            if (updates.priority !== undefined) {
+                args.push('--priority', String(updates.priority));
+            }
+            args.push('--json');
+            const output = await execBd(args, context);
+            // bd update returns an array, take the first element
+            const issues = parseJson(output);
+            if (!issues || issues.length === 0) {
+                throw new ProviderErrorClass('OPERATION_FAILED', 'Update returned no results', 'beads');
+            }
+            return beadsIssueToProviderNode(issues[0]);
+        },
+        async delete(id, context) {
+            // Parse URI if full URI is passed
+            const parsed = this.parseUri(id);
+            const issueId = parsed?.id ?? id;
+            await execBd(['delete', issueId, '--force'], context);
+        },
+        // =========================================================================
+        // Search
+        // =========================================================================
+        async search(query, options) {
+            const args = ['search', query, '--json'];
+            if (options?.limit) {
+                args.push('--limit', String(options.limit));
+            }
+            const output = await execBd(args);
+            const issues = parseJson(output);
+            return issues
+                .filter((issue) => issue.status !== 'tombstone')
+                .map((issue) => beadsIssueToProviderNode(issue));
+        },
+        // =========================================================================
+        // RelationshipQueryable Implementation
+        // =========================================================================
+        async queryEdges(nodeId, options) {
+            // Parse URI if full URI is passed
+            const parsed = this.parseUri(nodeId);
+            const issueId = parsed?.id ?? nodeId;
+            try {
+                const output = await execBd(['show', issueId, '--json']);
+                const issues = parseJson(output);
+                if (!issues || issues.length === 0) {
+                    return [];
+                }
+                const issue = issues[0];
+                // Tombstoned issues have no meaningful edges
+                if (issue.status === 'tombstone') {
+                    return [];
+                }
+                let edges = [];
+                // --- Legacy format: blocks/blockedBy string arrays ---
+                if (issue.blocks && Array.isArray(issue.blocks)) {
+                    for (const blockedId of issue.blocks) {
+                        edges.push({ from: issueId, to: blockedId, type: 'blocks' });
+                    }
+                }
+                if (issue.blockedBy && Array.isArray(issue.blockedBy)) {
+                    for (const blockerId of issue.blockedBy) {
+                        edges.push({ from: blockerId, to: issueId, type: 'blocks' });
+                    }
+                }
+                // --- bd v0.49+ format from `bd show --json` ---
+                // `dependencies` = issues THIS issue depends on (they block this)
+                // Each element is a full issue object with an `id` field
+                if (issue.dependencies && Array.isArray(issue.dependencies)) {
+                    for (const dep of issue.dependencies) {
+                        if (dep.id) {
+                            // Full object format from `bd show` — dep.id is the blocker
+                            edges.push({ from: dep.id, to: issueId, type: 'blocks' });
+                        }
+                        else if (dep.depends_on_id && dep.issue_id) {
+                            // Compact format from `bd list` — depends_on_id blocks issue_id
+                            edges.push({ from: dep.depends_on_id, to: dep.issue_id, type: 'blocks' });
+                        }
+                    }
+                }
+                // `dependents` = issues that depend on THIS issue (this blocks them)
+                if (issue.dependents && Array.isArray(issue.dependents)) {
+                    for (const dep of issue.dependents) {
+                        if (dep.id) {
+                            edges.push({ from: issueId, to: dep.id, type: 'blocks' });
+                        }
+                    }
+                }
+                // --- Parent/children ---
+                if (issue.parent) {
+                    edges.push({ from: issue.parent, to: issueId, type: 'parent-child' });
+                }
+                if (issue.children && Array.isArray(issue.children)) {
+                    for (const childId of issue.children) {
+                        edges.push({ from: issueId, to: childId, type: 'parent-child' });
+                    }
+                }
+                // Deduplicate edges (multiple formats may report the same relationship)
+                const seen = new Set();
+                edges = edges.filter((edge) => {
+                    const key = `${edge.from}:${edge.to}:${edge.type}`;
+                    if (seen.has(key))
+                        return false;
+                    seen.add(key);
+                    return true;
+                });
+                // Apply filters if specified
+                if (options?.edgeType) {
+                    edges = filterEdgesByType(edges, options.edgeType);
+                }
+                if (options?.direction) {
+                    edges = filterEdgesByDirection(edges, issueId, options.direction);
+                }
+                if (options?.limit && edges.length > options.limit) {
+                    edges = edges.slice(0, options.limit);
+                }
+                return edges;
+            }
+            catch (error) {
+                // Return empty for not found, re-throw other errors
+                if (error instanceof ProviderErrorClass && error.code === 'OPERATION_FAILED') {
+                    const message = error.message.toLowerCase();
+                    if (message.includes('not found') ||
+                        message.includes('does not exist') ||
+                        message.includes('no issue found matching')) {
+                        return [];
+                    }
+                }
+                throw error;
+            }
+        },
+        supportedEdgeTypes() {
+            return [
+                { type: 'blocks', canQuery: true, canCreate: true, canDelete: true },
+                { type: 'parent-child', canQuery: true, canCreate: true, canDelete: true },
+            ];
+        },
+        // =========================================================================
+        // Watchable Implementation (only functional when watchPath is configured)
+        // =========================================================================
+        watchGranularity: {
+            // Beads diffs at the node level. We can detect which nodes changed
+            // but don't track individual field changes (would require caching
+            // full issue objects rather than just hashes).
+            reportsChangedFields: false,
+            reportsPreviousValues: false,
+            // Beads embeds relationships in the node (blocks/blockedBy/parent/children).
+            // We extract and diff these separately, so we can emit edge events.
+            reportsEdgeChanges: true,
+            mechanism: 'file-watch',
+        },
+        startWatching(callback) {
+            if (!watchPath) {
+                return; // Watching not configured — silently no-op
+            }
+            // Replace callback if already watching
+            watchCallback = callback;
+            if (fileWatcher) {
+                return; // Already watching, just updated callback
+            }
+            // Seed cache before starting watcher so we only emit real changes
+            void seedCache().then(() => {
+                if (!watchCallback)
+                    return; // Stopped before seed completed
+                fileWatcher = chokidar.watch(watchPath, {
+                    ignoreInitial: true,
+                    persistent: true,
+                    awaitWriteFinish: {
+                        stabilityThreshold: 100,
+                        pollInterval: 20,
+                    },
+                });
+                fileWatcher.on('add', onFileChange);
+                fileWatcher.on('change', onFileChange);
+                fileWatcher.on('unlink', onFileChange);
+                fileWatcher.on('error', () => {
+                    // Resilient — continue watching despite transient errors
+                });
+            });
+        },
+        stopWatching() {
+            watchCallback = null;
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = null;
+            }
+            if (fileWatcher) {
+                void fileWatcher.close();
+                fileWatcher = null;
+            }
+        },
+        get isWatching() {
+            return fileWatcher !== null && watchCallback !== null;
+        },
+        // =========================================================================
+        // TaskManageable Implementation
+        // =========================================================================
+        taskCapabilities: {
+            actions: ['start', 'complete', 'block', 'reopen', 'close'],
+            supportsAssignment: true,
+            supportsReadyQuery: true,
+            statusModel: ['open', 'in_progress', 'blocked', 'closed'],
+        },
+        async transitionTask(id, action, context) {
+            const statusMap = {
+                start: 'in_progress',
+                complete: 'closed',
+                block: 'blocked',
+                reopen: 'open',
+                close: 'closed',
+            };
+            const targetStatus = statusMap[action];
+            if (!targetStatus) {
+                throw new ProviderErrorClass('NOT_SUPPORTED', `Unsupported task action: ${action}`, 'beads');
+            }
+            const parsed = this.parseUri(id);
+            const issueId = parsed?.id ?? id;
+            // Validate transition is allowed from current state
+            const current = await this.get(issueId, context);
+            if (current) {
+                const currentStatus = current.status ?? 'open';
+                const allowed = validActionsForStatus(currentStatus);
+                if (!allowed.includes(action)) {
+                    throw new ProviderErrorClass('NOT_SUPPORTED', `Cannot ${action} an issue in '${currentStatus}' state. Valid actions: ${allowed.join(', ')}`, 'beads');
+                }
+            }
+            const output = await execBd(['update', issueId, '--status', targetStatus, '--json'], context);
+            const issues = parseJson(output);
+            if (!issues || issues.length === 0) {
+                throw new ProviderErrorClass('OPERATION_FAILED', 'Transition returned no results', 'beads');
+            }
+            return beadsIssueToProviderNode(issues[0]);
+        },
+        async readyTasks(options, context) {
+            const output = await execBd(['list', '--json'], context);
+            const issues = parseJson(output);
+            const readyIssues = [];
+            for (const issue of issues) {
+                // Skip tombstoned and non-open issues
+                if (issue.status === 'tombstone' || issue.status !== 'open')
+                    continue;
+                // Apply tag filter
+                if (options?.tags) {
+                    const issueTags = issue.tags ?? [];
+                    if (!options.tags.every((t) => issueTags.includes(t)))
+                        continue;
+                }
+                // Apply priority filter
+                if (options?.priority !== undefined) {
+                    const normalized = mapPriority(issue.priority);
+                    if (normalized === undefined || normalized > options.priority)
+                        continue;
+                }
+                // Apply assignee filter
+                if (options?.assignee) {
+                    if (issue.assignee !== options.assignee)
+                        continue;
+                }
+                // Check for active blockers
+                let hasActiveBlocker = false;
+                // Legacy format: blockedBy
+                if (issue.blockedBy && issue.blockedBy.length > 0) {
+                    // Need to check if blockers are still active
+                    for (const blockerId of issue.blockedBy) {
+                        try {
+                            const blockerOutput = await execBd(['show', blockerId, '--json'], context);
+                            const blockerIssues = parseJson(blockerOutput);
+                            if (blockerIssues?.[0] &&
+                                blockerIssues[0].status !== 'closed' &&
+                                blockerIssues[0].status !== 'tombstone') {
+                                hasActiveBlocker = true;
+                                break;
+                            }
+                        }
+                        catch {
+                            // If we can't resolve the blocker, assume it's active
+                            hasActiveBlocker = true;
+                            break;
+                        }
+                    }
+                }
+                // Structured format (bd v0.49+): dependencies
+                if (!hasActiveBlocker && issue.dependencies && issue.dependencies.length > 0) {
+                    for (const dep of issue.dependencies) {
+                        const depId = dep.id ?? dep.depends_on_id;
+                        if (!depId)
+                            continue;
+                        try {
+                            const depOutput = await execBd(['show', depId, '--json'], context);
+                            const depIssues = parseJson(depOutput);
+                            if (depIssues?.[0] &&
+                                depIssues[0].status !== 'closed' &&
+                                depIssues[0].status !== 'tombstone') {
+                                hasActiveBlocker = true;
+                                break;
+                            }
+                        }
+                        catch {
+                            hasActiveBlocker = true;
+                            break;
+                        }
+                    }
+                }
+                if (!hasActiveBlocker) {
+                    readyIssues.push(beadsIssueToProviderNode(issue));
+                }
+            }
+            // Sort by priority (lower number = higher priority)
+            readyIssues.sort((a, b) => {
+                const aPriority = a.priority ?? Infinity;
+                const bPriority = b.priority ?? Infinity;
+                return aPriority - bPriority;
+            });
+            // Apply limit
+            if (options?.limit && readyIssues.length > options.limit) {
+                return readyIssues.slice(0, options.limit);
+            }
+            return readyIssues;
+        },
+        async assignTask(id, assignee, context) {
+            const parsed = this.parseUri(id);
+            const issueId = parsed?.id ?? id;
+            const output = await execBd(['update', issueId, '--assignee', assignee, '--json'], context);
+            const issues = parseJson(output);
+            if (!issues || issues.length === 0) {
+                throw new ProviderErrorClass('OPERATION_FAILED', 'Assign returned no results', 'beads');
+            }
+            return beadsIssueToProviderNode(issues[0]);
+        },
+        async validActions(id, context) {
+            const node = await this.get(id, context);
+            if (!node) {
+                throw new ProviderErrorClass('NOT_FOUND', `Issue not found: ${id}`, 'beads');
+            }
+            return validActionsForStatus(node.status ?? 'open');
+        },
+    };
+}
+//# sourceMappingURL=beads.js.map