@taskforcehq/taskforce 0.3.168

package/dist/__tests__/workflowV2Policy.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+const WORKFLOW_DIR = path.resolve(process.cwd(), 'src/resources/templates/workflows');
+const semverLike = (value) => /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value);
+describe('Workflow v2 policy', () => {
+    const files = fs.readdirSync(WORKFLOW_DIR).filter((f) => f.endsWith('.yaml'));
+    const docs = files.map((file) => {
+        const full = path.join(WORKFLOW_DIR, file);
+        const parsed = yaml.load(fs.readFileSync(full, 'utf8'));
+        return { file, parsed };
+    });
+    it('all workflows are v2 with required top-level policy blocks', () => {
+        for (const { file, parsed } of docs) {
+            expect(parsed.version, `${file} should be version 2`).toBe(2);
+            expect(parsed.type, `${file} should be workflow type`).toBe('workflow');
+            expect(parsed.dispatch, `${file} missing dispatch`).toBeTruthy();
+            expect(parsed.compat, `${file} missing compat`).toBeTruthy();
+            expect(parsed.toolPolicy, `${file} missing toolPolicy`).toBeTruthy();
+            expect(parsed.contextPolicy, `${file} missing contextPolicy`).toBeTruthy();
+            expect(parsed.content?.default, `${file} missing content.default`).toBeTruthy();
+        }
+    });
+    it('uses semver-like minTaskforceVersion', () => {
+        for (const { file, parsed } of docs) {
+            const version = parsed.compat?.minTaskforceVersion || '';
+            expect(semverLike(version), `${file} has invalid minTaskforceVersion: ${version}`).toBe(true);
+        }
+    });
+    it('splits required tools into critical and optional lists', () => {
+        for (const { file, parsed } of docs) {
+            const critical = parsed.compat?.requiredToolsCritical || [];
+            const optional = parsed.compat?.requiredToolsOptional || [];
+            expect(Array.isArray(critical), `${file} missing requiredToolsCritical`).toBe(true);
+            expect(Array.isArray(optional), `${file} missing requiredToolsOptional`).toBe(true);
+            expect(critical.length > 0, `${file} requiredToolsCritical should not be empty`).toBe(true);
+            expect(new Set(critical).size === critical.length, `${file} requiredToolsCritical has duplicates`).toBe(true);
+            expect(new Set(optional).size === optional.length, `${file} requiredToolsOptional has duplicates`).toBe(true);
+            for (const tool of critical) {
+                expect(optional.includes(tool), `${file} tool listed as both critical and optional: ${tool}`).toBe(false);
+            }
+        }
+    });
+    it('enforces requiredToolsPolicy and status safety defaults', () => {
+        for (const { file, parsed } of docs) {
+            expect(parsed.toolPolicy?.requiredToolsPolicy?.critical, `${file} critical policy`).toBe('strict-fail');
+            expect(parsed.toolPolicy?.requiredToolsPolicy?.nonCritical, `${file} nonCritical policy`).toBe('warn-and-fallback');
+            expect(parsed.toolPolicy?.statusTransitions?.allowedStatuses).toEqual(expect.arrayContaining(['task', 'on-hold', 'in-progress', 'review']));
+            expect(parsed.toolPolicy?.statusTransitions?.forbiddenStatuses).toEqual(expect.arrayContaining(['done', 'cancelled']));
+        }
+    });
+    it('uses explicit MCP unavailable action', () => {
+        for (const { file, parsed } of docs) {
+            expect(parsed.contextPolicy?.mcpUnavailableAction, `${file} missing mcpUnavailableAction`).toBeTruthy();
+        }
+    });
+    it('keeps artifact paths project-root-relative', () => {
+        for (const { file, parsed } of docs) {
+            const artifacts = parsed.artifacts || {};
+            for (const [artifactName, def] of Object.entries(artifacts)) {
+                expect(path.isAbsolute(def.path), `${file} ${artifactName} path must be relative`).toBe(false);
+                expect(def.path.includes('..'), `${file} ${artifactName} path must not escape project root`).toBe(false);
+            }
+        }
+    });
+    it('defines global approach routing in do workflow', () => {
+        const doDoc = docs.find((d) => d.parsed.name === 'do');
+        expect(doDoc, 'do workflow is missing').toBeTruthy();
+        expect(doDoc?.parsed.dispatch?.routeByApproach).toBe(true);
+        expect(doDoc?.parsed.dispatch?.approachMap).toEqual(expect.objectContaining({
+            evaluate: 'evaluate',
+            collaborate: 'collaborate',
+            plan: 'plan',
+            review: 'review',
+            implement: 'execute'
+        }));
+        expect(doDoc?.parsed.dispatch?.default).toBe('execute');
+    });
+});

package/dist/api.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Taskforce Manager - API Client
+ *
+ * Backend-first API helpers.
+ */
+import type { TaskItem } from './types';
+/**
+ * Submit a task item to the backend
+ */
+export declare function submitTask(task: Omit<TaskItem, 'id' | 'completedAt'>, apiEndpoint: string): Promise<{
+    success: boolean;
+    fallback?: boolean;
+    error?: string;
+}>;
+/**
+ * Pending queue is deprecated; returns empty for compatibility.
+ */
+export declare function getPendingTasks(): TaskItem[];
+/**
+ * Pending queue is deprecated; no-op for compatibility.
+ */
+export declare function clearPendingTasks(): void;
+/**
+ * Export pending tasks as markdown string
+ */
+export declare function exportTasksAsMarkdown(): string;
+/**
+ * Copy pending tasks to clipboard as markdown
+ */
+export declare function copyTasksToClipboard(): Promise<boolean>;

package/dist/api.js

@@ -0,0 +1,85 @@
+/**
+ * Taskforce Manager - API Client
+ *
+ * Backend-first API helpers.
+ */
+/**
+ * Submit a task item to the backend
+ */
+export async function submitTask(task, apiEndpoint) {
+    const taskWithId = {
+        ...task,
+        id: crypto.randomUUID(),
+    };
+    try {
+        const response = await fetch(apiEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(taskWithId),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error?.message || 'Network error' };
+    }
+}
+/**
+ * Pending queue is deprecated; returns empty for compatibility.
+ */
+export function getPendingTasks() {
+    return [];
+}
+/**
+ * Pending queue is deprecated; no-op for compatibility.
+ */
+export function clearPendingTasks() {
+    // no-op
+}
+/**
+ * Export pending tasks as markdown string
+ */
+export function exportTasksAsMarkdown() {
+    const tasks = getPendingTasks();
+    if (tasks.length === 0)
+        return '';
+    const grouped = tasks.reduce((acc, task) => {
+        if (!acc[task.category])
+            acc[task.category] = [];
+        acc[task.category].push(task);
+        return acc;
+    }, {});
+    let markdown = '# Pending Taskforce Tasks\n\n';
+    for (const [category, items] of Object.entries(grouped)) {
+        markdown += `## ${category}\n\n`;
+        for (const item of items) {
+            const checkbox = item.completedAt ? '[x]' : '[ ]';
+            const priority = String(item.priority);
+            markdown += `- ${checkbox} **${item.title}** [P${priority}]\n`;
+            if (item.description) {
+                markdown += `  - ${item.description}\n`;
+            }
+            markdown += `  - Added: ${item.createdAt}\n\n`;
+        }
+    }
+    return markdown;
+}
+/**
+ * Copy pending tasks to clipboard as markdown
+ */
+export async function copyTasksToClipboard() {
+    const markdown = exportTasksAsMarkdown();
+    if (!markdown)
+        return false;
+    try {
+        await navigator.clipboard.writeText(markdown);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import { exec } from 'child_process';
+import { platform } from 'os';
+import { readFileSync, existsSync, realpathSync } from 'fs';
+import { join, dirname } from 'path';
+/**
+ * Taskforce CLI
+ *
+ * Usage:
+ * npx taskforce open [port]
+ */
+const args = process.argv.slice(2);
+const command = args[0] || 'open';
+function normalizeOpenEnvironmentPreset(raw) {
+    const normalized = String(raw || '').trim().toLowerCase();
+    if (normalized === 'production')
+        return 'production';
+    if (normalized === 'staging')
+        return 'staging';
+    if (normalized === 'performance')
+        return 'performance';
+    return null;
+}
+function parseOpenCommandOptions(argv) {
+    const fallbackPort = 5174;
+    const arg1 = String(argv[1] || '').trim();
+    const arg2 = String(argv[2] || '').trim();
+    if (!arg1)
+        return { preferredPort: fallbackPort, preset: null };
+    const arg1AsPort = parseInt(arg1, 10);
+    if (!isNaN(arg1AsPort)) {
+        return { preferredPort: arg1AsPort, preset: null };
+    }
+    const preset = normalizeOpenEnvironmentPreset(arg1);
+    if (!preset) {
+        console.error('\x1b[31m❌ Invalid open target.\x1b[0m Use a port or one of: production, staging, performance');
+        process.exit(1);
+    }
+    if (!arg2)
+        return { preferredPort: fallbackPort, preset };
+    const arg2AsPort = parseInt(arg2, 10);
+    if (isNaN(arg2AsPort)) {
+        console.error('\x1b[31m❌ Invalid port.\x1b[0m Example: taskforce open staging 5178');
+        process.exit(1);
+    }
+    return { preferredPort: arg2AsPort, preset };
+}
+/**
+ * Find project root by traversing up to find package.json with taskforce
+ */
+function findProjectRoot() {
+    let currentDir = process.cwd();
+    const root = dirname(currentDir);
+    let depth = 0;
+    while (currentDir !== root && depth < 10) {
+        const packageJsonPath = join(currentDir, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+                const hasDep = pkg.dependencies?.['@taskforcehq/taskforce'] || pkg.dependencies?.taskforce || pkg.dependencies?.Taskforce;
+                const hasDevDep = pkg.devDependencies?.['@taskforcehq/taskforce'] || pkg.devDependencies?.taskforce || pkg.devDependencies?.Taskforce;
+                const isSelf = pkg.name === '@taskforcehq/taskforce' || pkg.name === 'taskforce' || pkg.name === 'Taskforce';
+                if (hasDep || hasDevDep || isSelf) {
+                    try {
+                        return realpathSync(currentDir);
+                    }
+                    catch {
+                        return currentDir;
+                    }
+                }
+            }
+            catch (e) {
+                // Invalid package.json, continue searching
+            }
+        }
+        currentDir = dirname(currentDir);
+        depth++;
+    }
+    return null;
+}
+/**
+ * Open browser to the given URL
+ */
+function openBrowser(url) {
+    const browserEnv = String(process.env.BROWSER || '').trim().toLowerCase();
+    if (browserEnv === 'none' || browserEnv === 'false' || browserEnv === '0') {
+        console.log('\x1b[36m[Taskforce] Browser auto-open disabled by BROWSER env\x1b[0m');
+        return;
+    }
+    const start = (platform() === 'darwin' ? 'open' : platform() === 'win32' ? 'start' : 'xdg-open');
+    exec(`${start} ${url}`);
+}
+/**
+ * Main CLI logic
+ */
+async function main() {
+    if (command === 'help' || (command !== 'open' && command !== 'mcp')) {
+        console.log('\x1b[35mTaskforce CLI\x1b[0m');
+        console.log('\nUsage:');
+        console.log('  taskforce <command> [options]');
+        console.log('\nAvailable commands:');
+        console.log('  open [port]                         - Starts Taskforce on an unused port and opens it (default start port 5174)');
+        console.log('  open <production|staging|performance> [port]   - Starts Taskforce with preset cloud endpoints');
+        console.log('  mcp [path]      - Starts the Model Context Protocol (MCP) server for the specified project');
+        console.log('  help            - Shows this help message');
+        return;
+    }
+    // 1. Handle MCP Command
+    if (command === 'mcp') {
+        const projectPath = args[1] || process.cwd();
+        // Set the path in argv so the mcp server can pick it up
+        process.argv[2] = projectPath;
+        try {
+            console.error(`\x1b[32m✓ Starting Taskforce MCP server for ${projectPath}\x1b[0m`);
+            // Import the MCP server - it will start automatically via its top-level await
+            await import('./mcp/server.js');
+        }
+        catch (e) {
+            console.error('\x1b[31m❌ Failed to start MCP server:\x1b[0m', e);
+            process.exit(1);
+        }
+        return;
+    }
+    // 2. Handle Open Command
+    const { preferredPort, preset: openPreset } = parseOpenCommandOptions(args);
+    // Check if Taskforce is installed in the project
+    let projectRoot = findProjectRoot();
+    if (!projectRoot) {
+        // Fallback to CWD for global/npx usage
+        // We don't exit anymore, enabling "npx taskforce open" or global install usage
+        projectRoot = process.cwd();
+        // Optional: warn if no package.json found at all?
+        // For now, silent fallback is better for "just works" experience
+    }
+    console.log(`\x1b[32m✓ Found Taskforce in ${projectRoot}\x1b[0m`);
+    // 2. Always start a new server on an unused port
+    console.log(`\x1b[36m✨ Starting Taskforce server on an unused port...\x1b[0m`);
+    try {
+        // Local CLI launches should default to local runtime unless explicitly overridden.
+        // This prevents ambient TASKFORCE_DB_PROVIDER=postgres from flipping runtime to cloud.
+        if (!process.env.TASKFORCE_RUNTIME_MODE) {
+            process.env.TASKFORCE_RUNTIME_MODE = 'local';
+        }
+        const hasExternalCloudEndpoint = Boolean(String(process.env.VITE_TASKFORCE_BASE_URL || '').trim()
+            || String(process.env.TASKFORCE_BASE_URL || '').trim()
+            || String(process.env.VITE_TASKFORCE_API_BASE_URL || '').trim()
+            || String(process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL || '').trim());
+        const effectivePreset = openPreset || (hasExternalCloudEndpoint ? null : 'production');
+        if (effectivePreset === 'production') {
+            process.env.VITE_TASKFORCE_BASE_URL = 'https://app.taskforcehq.ai';
+            process.env.VITE_TASKFORCE_API_BASE_URL = 'https://app.taskforcehq.ai';
+            process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL = 'https://app.taskforcehq.ai';
+            console.log('\x1b[36m[Taskforce] Using production cloud endpoint preset\x1b[0m');
+        }
+        else if (effectivePreset === 'staging') {
+            process.env.VITE_TASKFORCE_BASE_URL = 'https://staging-app.taskforcehq.ai';
+            process.env.VITE_TASKFORCE_API_BASE_URL = 'https://staging-app.taskforcehq.ai';
+            process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL = 'https://staging-app.taskforcehq.ai';
+            console.log('\x1b[36m[Taskforce] Using staging cloud endpoint preset\x1b[0m');
+        }
+        else if (effectivePreset === 'performance') {
+            process.env.VITE_TASKFORCE_BASE_URL = 'https://performance-app.taskforcehq.ai';
+            process.env.VITE_TASKFORCE_API_BASE_URL = 'https://performance-app.taskforcehq.ai';
+            process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL = 'https://performance-app.taskforcehq.ai';
+            console.log('\x1b[36m[Taskforce] Using performance cloud endpoint preset\x1b[0m');
+        }
+        else if (hasExternalCloudEndpoint) {
+            console.log('\x1b[36m[Taskforce] Using cloud endpoint from environment variables\x1b[0m');
+        }
+        const { createStandaloneServer } = await import('./server/index.js');
+        const { createServer } = await import('net');
+        /**
+         * Find a free port starting from preferredPort
+         */
+        const findPort = (port, maxPort) => {
+            return new Promise((resolve, reject) => {
+                const s = createServer();
+                s.on('error', (err) => {
+                    const retryable = err?.code === 'EADDRINUSE' || err?.code === 'EACCES' || err?.code === 'EPERM';
+                    if (retryable) {
+                        if (port < maxPort) {
+                            resolve(findPort(port + 1, maxPort));
+                        }
+                        else {
+                            reject(new Error(`No available ports found between ${preferredPort} and ${maxPort}`));
+                        }
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+                s.listen(port, () => {
+                    s.close(() => resolve(port));
+                });
+            });
+        };
+        const targetPort = await findPort(preferredPort, preferredPort + 10);
+        const server = createStandaloneServer({
+            projectRoot,
+            port: targetPort
+        });
+        server.listen(targetPort, () => {
+            const url = `http://localhost:${targetPort}/taskforce/`;
+            console.log(`\x1b[32m✓ Server started on port ${targetPort}\x1b[0m`);
+            console.log(`\x1b[35m🚀 Opening ${url}...\x1b[0m`);
+            openBrowser(url);
+        });
+    }
+    catch (e) {
+        console.error('\x1b[31m❌ Failed to start server:\x1b[0m', e.message);
+        process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error('\x1b[31mError:\x1b[0m', err.message);
+    process.exit(1);
+});

package/dist/compat/priorityCompat.d.ts

@@ -0,0 +1,2 @@
+export declare const PRIORITY_LOGIC: Record<string, number>;
+export declare function getLegacyPriorityClass(priority: string | number, fallbackLabel: string): string;

package/dist/compat/priorityCompat.js

@@ -0,0 +1,24 @@
+import { MIGRATION_COMPAT_ENABLED } from '../migrations/flags';
+export const PRIORITY_LOGIC = {
+    'on-hold': 1,
+    low: 1,
+    medium: 2,
+    high: 3,
+    critical: 4
+};
+const LEGACY_PRIORITY_CLASS_MAP = {
+    '0': 'low',
+    '1': 'low',
+    '2': 'medium',
+    '3': 'high',
+    '4': 'critical',
+    '5': 'critical'
+};
+export function getLegacyPriorityClass(priority, fallbackLabel) {
+    // COMPAT_REMOVE_AFTER: v1.0.0
+    // COMPAT_TRACK: priority-scale-0-to-4
+    if (!MIGRATION_COMPAT_ENABLED && Number(priority) === 0) {
+        return fallbackLabel;
+    }
+    return LEGACY_PRIORITY_CLASS_MAP[String(priority)] || fallbackLabel;
+}

package/dist/components/features/DocumentGenerateModal.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    content: string;
+    docTitle: string;
+    apiBaseUrl?: string;
+    onClose: () => void;
+    onGenerated: (count: number) => void;
+}
+export declare function DocumentGenerateModal({ content, docTitle, apiBaseUrl, onClose, onGenerated }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/features/DocumentGenerateModal.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useCallback, useEffect } from 'react';
+import { Zap, ChevronRight, ChevronDown, CheckSquare, Square, X, Loader, CheckCircle, AlertCircle } from 'lucide-react';
+import styles from '../../Taskforce.module.css';
+import { fetchTaskforceApi } from '../../utils/taskforceApiClient';
+const TYPE_COLORS = {
+    feature: '#a78bfa',
+    bug: '#f87171',
+    chore: '#94a3b8',
+    refactor: '#fbbf24',
+    documentation: '#34d399',
+};
+const PRIORITY_LABELS = { 1: 'Low', 2: 'Medium', 3: 'High', 4: 'Critical' };
+const PRIORITY_COLORS = {
+    1: '#64748b', 2: '#94a3b8', 3: '#f97316', 4: '#ef4444',
+};
+// ─── Task tree node (UI-mutable copy) ────────────────────────────────────────
+function toggleAll(nodes, selected) {
+    return nodes.map(n => ({ ...n, selected, children: toggleAll(n.children, selected) }));
+}
+function toggleNode(nodes, key, selected) {
+    return nodes.map(n => {
+        if (n.idempotencyKey === key) {
+            return { ...n, selected, children: toggleAll(n.children, selected) };
+        }
+        return { ...n, children: toggleNode(n.children, key, selected) };
+    });
+}
+function countSelected(nodes) {
+    let count = 0;
+    for (const n of nodes) {
+        if (n.selected)
+            count++;
+        count += countSelected(n.children);
+    }
+    return count;
+}
+function TreeNode({ node, depth, onToggle }) {
+    const [expanded, setExpanded] = useState(true);
+    const hasChildren = node.children.length > 0;
+    const indentPx = depth * 20;
+    return (_jsxs("div", { children: [_jsxs("div", { className: `${styles.genTaskRow} ${!node.selected ? styles.genTaskRowDimmed : ''}`, style: { paddingLeft: `${12 + indentPx}px` }, children: [_jsx("button", { className: styles.genTaskCheck, onClick: () => onToggle(node.idempotencyKey, !node.selected), title: node.selected ? 'Deselect' : 'Select', children: node.selected
+                            ? _jsx(CheckSquare, { size: 14, style: { color: '#a78bfa' } })
+                            : _jsx(Square, { size: 14, style: { color: '#64748b' } }) }), hasChildren ? (_jsx("button", { className: styles.genTaskExpandBtn, onClick: () => setExpanded(e => !e), children: expanded ? _jsx(ChevronDown, { size: 12 }) : _jsx(ChevronRight, { size: 12 }) })) : (_jsx("span", { className: styles.genTaskExpandSpacer })), _jsx("span", { className: styles.genTaskTitle, title: node.description || undefined, children: node.title }), _jsx("span", { className: styles.genTaskBadge, style: { color: TYPE_COLORS[node.type] ?? '#a78bfa', borderColor: TYPE_COLORS[node.type] ?? '#a78bfa' }, children: node.type }), _jsx("span", { className: styles.genTaskBadge, style: { color: PRIORITY_COLORS[node.priority] ?? '#94a3b8', borderColor: PRIORITY_COLORS[node.priority] ?? '#94a3b8' }, children: PRIORITY_LABELS[node.priority] })] }), hasChildren && expanded && (_jsx("div", { children: node.children.map(child => (_jsx(TreeNode, { node: child, depth: depth + 1, onToggle: onToggle }, child.idempotencyKey))) }))] }));
+}
+// ─── Modal ────────────────────────────────────────────────────────────────────
+export function DocumentGenerateModal({ content, docTitle, apiBaseUrl = '', onClose, onGenerated }) {
+    const [state, setState] = useState('preview');
+    const [loadError, setLoadError] = useState(null);
+    const [tasks, setTasks] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [generatedCount, setGeneratedCount] = useState(0);
+    const [genError, setGenError] = useState(null);
+    // Fetch preview on mount
+    useEffect(() => {
+        let cancelled = false;
+        setLoading(true);
+        setLoadError(null);
+        fetchTaskforceApi('/api/taskforce/documents/generate-tasks/preview', {
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ content }),
+        }, apiBaseUrl)
+            .then(r => r.json())
+            .then(data => {
+            if (cancelled)
+                return;
+            if (data.error)
+                throw new Error(data.error);
+            setTasks(data.tasks || []);
+            setState('preview');
+        })
+            .catch(e => {
+            if (cancelled)
+                return;
+            setLoadError(e?.message || 'Failed to parse plan');
+            setState('error');
+        })
+            .finally(() => { if (!cancelled)
+            setLoading(false); });
+        return () => { cancelled = true; };
+    }, [content, apiBaseUrl]);
+    const handleToggle = useCallback((key, selected) => {
+        setTasks(prev => toggleNode(prev, key, selected));
+    }, []);
+    const handleSelectAll = () => setTasks(prev => toggleAll(prev, true));
+    const handleSelectNone = () => setTasks(prev => toggleAll(prev, false));
+    const selectedCount = countSelected(tasks);
+    const handleGenerate = async () => {
+        setState('generating');
+        setGenError(null);
+        try {
+            const res = await fetchTaskforceApi('/api/taskforce/documents/generate-tasks/commit', {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ tasks }),
+            }, apiBaseUrl);
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok)
+                throw new Error(data.error || `Generation failed (${res.status})`);
+            setGeneratedCount(data.created ?? 0);
+            setState('done');
+            onGenerated(data.created ?? 0);
+        }
+        catch (e) {
+            setGenError(e?.message || 'Generation failed');
+            setState('error');
+        }
+    };
+    return (_jsx("div", { className: styles.genModalOverlay, onClick: e => { if (e.target === e.currentTarget)
+            onClose(); }, children: _jsxs("div", { className: styles.genModal, children: [_jsxs("div", { className: styles.genModalHeader, children: [_jsxs("div", { className: styles.genModalTitle, children: [_jsx(Zap, { size: 16, style: { color: '#a78bfa' } }), "Generate Tasks from Plan"] }), _jsx("span", { className: styles.genModalDocName, children: docTitle }), _jsx("button", { className: styles.genModalClose, onClick: onClose, title: "Close", children: _jsx(X, { size: 16 }) })] }), _jsxs("div", { className: styles.genModalBody, children: [loading && (_jsxs("div", { className: styles.genModalState, children: [_jsx(Loader, { size: 20, className: styles.docSpinning }), "Parsing plan\u2026"] })), !loading && state === 'error' && (_jsxs("div", { className: styles.genModalStateError, children: [_jsx(AlertCircle, { size: 16 }), loadError || genError || 'An error occurred'] })), !loading && state === 'done' && (_jsxs("div", { className: styles.genModalStateDone, children: [_jsx(CheckCircle, { size: 24, style: { color: '#4ade80' } }), _jsxs("strong", { children: [generatedCount, " task", generatedCount !== 1 ? 's' : '', " created"] }), _jsx("p", { children: "Tasks are now in your board. Switch to the Kanban or Hierarchy view to see them." })] })), !loading && (state === 'preview' || state === 'confirm' || state === 'generating') && (_jsxs(_Fragment, { children: [_jsxs("div", { className: styles.genToolbar, children: [_jsxs("span", { className: styles.genToolbarCount, children: [selectedCount, " of ", countSelected(toggleAll(tasks, true)), " tasks selected"] }), _jsx("button", { className: styles.genToolbarBtn, onClick: handleSelectAll, children: "Select all" }), _jsx("button", { className: styles.genToolbarBtn, onClick: handleSelectNone, children: "Deselect all" })] }), tasks.length === 0 ? (_jsx("div", { className: styles.genModalState, children: "No tasks could be parsed from this document. Make sure the document uses ## H2 headings for phases and bullet points for tasks." })) : (_jsx("div", { className: styles.genTaskTree, children: tasks.map(task => (_jsx(TreeNode, { node: task, depth: 0, onToggle: handleToggle }, task.idempotencyKey))) }))] }))] }), !loading && state !== 'done' && state !== 'error' && (_jsxs("div", { className: styles.genModalFooter, children: [_jsx("button", { className: styles.genCancelBtn, onClick: onClose, children: "Cancel" }), _jsx("button", { className: styles.genCommitBtn, onClick: handleGenerate, disabled: selectedCount === 0 || state === 'generating', children: state === 'generating' ? (_jsxs(_Fragment, { children: [_jsx(Loader, { size: 13, className: styles.docSpinning }), " Generating\u2026"] })) : (_jsxs(_Fragment, { children: [_jsx(Zap, { size: 13 }), " Generate ", selectedCount, " task", selectedCount !== 1 ? 's' : ''] })) })] })), !loading && state === 'done' && (_jsx("div", { className: styles.genModalFooter, children: _jsx("button", { className: styles.genCommitBtn, onClick: onClose, children: "Done" }) }))] }) }));
+}

package/dist/components/features/DocumentIndex.d.ts

@@ -0,0 +1,19 @@
+import type { DocMeta } from './DocumentWorkspace';
+interface Props {
+    documents: DocMeta[];
+    selectedDocId: string | null;
+    loading: boolean;
+    error: string | null;
+    searchQuery: string;
+    typeFilter: DocMeta['docType'] | 'all';
+    taskById: Map<string, {
+        id: string;
+        title: string;
+    }>;
+    onSearchChange: (q: string) => void;
+    onTypeFilterChange: (t: DocMeta['docType'] | 'all') => void;
+    onSelect: (doc: DocMeta) => void;
+    onRefresh: () => void;
+}
+export declare function DocumentIndex({ documents, selectedDocId, loading, error, searchQuery, typeFilter, taskById, onSearchChange, onTypeFilterChange, onSelect, onRefresh, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/features/DocumentIndex.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Search, RefreshCw, FileText, ClipboardList, Eye, BookOpen, File } from 'lucide-react';
+import styles from '../../Taskforce.module.css';
+const DOC_TYPE_OPTIONS = [
+    { value: 'all', label: 'All' },
+    { value: 'implementation-plan', label: 'Plans' },
+    { value: 'review', label: 'Reviews' },
+    { value: 'walkthrough', label: 'Walkthroughs' },
+    { value: 'other', label: 'Other' },
+];
+function DocTypeIcon({ docType }) {
+    switch (docType) {
+        case 'implementation-plan': return _jsx(ClipboardList, { size: 13 });
+        case 'review': return _jsx(Eye, { size: 13 });
+        case 'walkthrough': return _jsx(BookOpen, { size: 13 });
+        default: return _jsx(File, { size: 13 });
+    }
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function formatRelativeDate(isoDate) {
+    if (!isoDate)
+        return '';
+    const d = new Date(isoDate);
+    const now = new Date();
+    const diffMs = now.getTime() - d.getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays === 0)
+        return 'Today';
+    if (diffDays === 1)
+        return 'Yesterday';
+    if (diffDays < 7)
+        return `${diffDays}d ago`;
+    if (diffDays < 30)
+        return `${Math.floor(diffDays / 7)}w ago`;
+    return d.toLocaleDateString();
+}
+export function DocumentIndex({ documents, selectedDocId, loading, error, searchQuery, typeFilter, taskById, onSearchChange, onTypeFilterChange, onSelect, onRefresh, }) {
+    return (_jsxs("div", { className: styles.docIndex, children: [_jsxs("div", { className: styles.docIndexHeader, children: [_jsxs("span", { className: styles.docIndexTitle, children: [_jsx(FileText, { size: 14 }), "Documents"] }), _jsx("button", { className: styles.docIndexRefreshBtn, onClick: onRefresh, title: "Refresh document list", disabled: loading, children: _jsx(RefreshCw, { size: 13, className: loading ? styles.docSpinning : undefined }) })] }), _jsxs("div", { className: styles.docIndexSearch, children: [_jsx(Search, { size: 12, className: styles.docIndexSearchIcon }), _jsx("input", { type: "text", placeholder: "Search documents\u2026", value: searchQuery, onChange: e => onSearchChange(e.target.value), className: styles.docIndexSearchInput })] }), _jsx("div", { className: styles.docIndexFilters, children: DOC_TYPE_OPTIONS.map(opt => (_jsx("button", { className: `${styles.docIndexFilterBtn} ${typeFilter === opt.value ? styles.docIndexFilterBtnActive : ''}`, onClick: () => onTypeFilterChange(opt.value), children: opt.label }, opt.value))) }), _jsxs("div", { className: styles.docIndexList, children: [loading && (_jsx("div", { className: styles.docIndexState, children: "Loading documents\u2026" })), !loading && error && (_jsx("div", { className: styles.docIndexStateError, children: error })), !loading && !error && documents.length === 0 && (_jsx("div", { className: styles.docIndexState, children: searchQuery || typeFilter !== 'all'
+                            ? 'No documents match your filters.'
+                            : 'No documents found. Documents added as task attachments will appear here.' })), !loading && documents.map(doc => {
+                        const task = doc.taskId ? taskById.get(doc.taskId) : null;
+                        const isSelected = doc.id === selectedDocId;
+                        return (_jsxs("button", { className: `${styles.docIndexItem} ${isSelected ? styles.docIndexItemActive : ''}`, onClick: () => onSelect(doc), children: [_jsx("div", { className: styles.docIndexItemIcon, children: _jsx(DocTypeIcon, { docType: doc.docType }) }), _jsxs("div", { className: styles.docIndexItemBody, children: [_jsx("span", { className: styles.docIndexItemTitle, children: doc.title }), task && (_jsx("span", { className: styles.docIndexItemTask, children: task.title })), _jsxs("span", { className: styles.docIndexItemMeta, children: [formatFileSize(doc.sizeBytes), doc.updatedAt && _jsxs(_Fragment, { children: [" \u00B7 ", formatRelativeDate(doc.updatedAt)] })] })] })] }, doc.id));
+                    })] })] }));
+}

package/dist/components/features/DocumentViewer.d.ts

@@ -0,0 +1,9 @@
+import type { DocMeta } from './DocumentWorkspace';
+interface Props {
+    doc: DocMeta;
+    taskTitle: string | null;
+    apiBaseUrl?: string;
+    onSaved?: (updatedAt: string) => void;
+}
+export declare function DocumentViewer({ doc, taskTitle, apiBaseUrl, onSaved }: Props): import("react/jsx-runtime").JSX.Element;
+export {};