@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/hooks/tasks/useTaskFormActions.d.ts

@@ -0,0 +1,58 @@
+import type { AttachmentItem, CategoryConfig, ChecklistItem, TaskAssignee, TaskItem, TaskStatus, TaxonomyDefinition, WorkstreamItem } from '../../types';
+interface UseTaskFormActionsInput {
+    activeCategories: CategoryConfig[];
+    activeTab: 'add' | 'tasks' | 'settings';
+    apiEndpoint: string;
+    approach: string;
+    assignee: TaskAssignee;
+    attachments: Array<string | AttachmentItem>;
+    attachmentsDirty: boolean;
+    category: string;
+    checklistItems: ChecklistItem[];
+    comments: TaskItem['comments'];
+    complexity: number | string;
+    description: string;
+    dueDate: string;
+    editingTaskId: string | null;
+    fetchTasks: (isSilent?: boolean) => Promise<void>;
+    formTaxonomies: Record<string, string | number | string[] | number[]>;
+    getPreferredCategoryValue: (categories: CategoryConfig[]) => string;
+    mergeTaskFromServer: (task: unknown) => void;
+    workstreamInput: string;
+    priority: number | string;
+    pushNotice: (message: string, tone?: 'success' | 'error' | 'info') => void;
+    queueWorkspaceSyncFromAuthoritativeTaskState: () => void;
+    relationshipTasks: TaskItem[];
+    resetForm: () => void;
+    resolveWorkstreamIdInput: (value: string) => WorkstreamItem | null;
+    scheduledDate: string;
+    setActiveTab: (tab: 'add' | 'tasks' | 'settings') => void;
+    setAttachmentsDirty: (value: boolean) => void;
+    setComments: (value: NonNullable<TaskItem['comments']>) => void;
+    setError: (value: string) => void;
+    setLastUsedCategory: (value: string) => void;
+    setLoading: (value: boolean) => void;
+    setNewCommentText: (value: string) => void;
+    status: TaskStatus;
+    title: string;
+    taxonomies: TaxonomyDefinition[];
+    type: string;
+}
+export type TaskAutoSaveState = 'idle' | 'saving' | 'saved' | 'error';
+export declare function useTaskFormActions(input: UseTaskFormActionsInput): {
+    autoSaveState: TaskAutoSaveState;
+    flushAutoSave: () => Promise<void>;
+    scheduleWarningPrompt: {
+        dueDate: string;
+        scheduledDate: string;
+    } | null;
+    saveTask: (options?: {
+        quiet?: boolean;
+        source?: "manual" | "autosave";
+    }) => Promise<boolean>;
+    handleSubmit: (event: React.FormEvent) => Promise<void>;
+    confirmScheduleWarning: () => Promise<void>;
+    cancelScheduleWarning: () => void;
+    handleAddComment: (text: string) => Promise<void>;
+};
+export {};

package/dist/hooks/tasks/useTaskFormActions.js

@@ -0,0 +1,365 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { DEFAULT_TYPE_VALUE } from '../../shared/taxonomyDefaults.js';
+import { normalizeTaskFromApi } from '../../utils/taskNormalization.js';
+export function useTaskFormActions(input) {
+    const { activeCategories, activeTab, apiEndpoint, approach, assignee, attachments, attachmentsDirty, category, checklistItems, comments, complexity, description, dueDate, editingTaskId, fetchTasks, formTaxonomies, getPreferredCategoryValue, mergeTaskFromServer, workstreamInput, priority, pushNotice, queueWorkspaceSyncFromAuthoritativeTaskState, relationshipTasks, resetForm, resolveWorkstreamIdInput, scheduledDate, setActiveTab, setAttachmentsDirty, setComments, setError, setLastUsedCategory, setLoading, setNewCommentText, status, title, taxonomies, type } = input;
+    const [scheduleWarningPrompt, setScheduleWarningPrompt] = useState(null);
+    const [autoSaveState, setAutoSaveState] = useState('idle');
+    const [lastSavedDraftSignature, setLastSavedDraftSignature] = useState(null);
+    const autoSaveTimerRef = useRef(null);
+    const buildTaskDraftSignature = useCallback(() => JSON.stringify({
+        title: title.trim(),
+        description: description || '',
+        category: typeof category === 'string'
+            ? category
+            : category.label || getPreferredCategoryValue(activeCategories),
+        type: typeof type === 'string' ? type : type.label || DEFAULT_TYPE_VALUE,
+        priority: Number(priority),
+        complexity: Number(complexity) || 3,
+        approach: approach || 'default',
+        assignee: assignee || 'agent',
+        scheduledDate: scheduledDate || '',
+        dueDate: dueDate || '',
+        workstreamInput: workstreamInput.trim(),
+        checklistItems,
+        comments,
+        taxonomies: formTaxonomies,
+        attachments,
+    }), [
+        activeCategories,
+        approach,
+        assignee,
+        attachments,
+        category,
+        checklistItems,
+        comments,
+        complexity,
+        description,
+        dueDate,
+        formTaxonomies,
+        getPreferredCategoryValue,
+        priority,
+        scheduledDate,
+        title,
+        type,
+        workstreamInput
+    ]);
+    const clearAutoSaveTimer = useCallback(() => {
+        if (autoSaveTimerRef.current !== null) {
+            window.clearTimeout(autoSaveTimerRef.current);
+            autoSaveTimerRef.current = null;
+        }
+    }, []);
+    const saveTask = useCallback(async (options) => {
+        const quiet = options?.quiet ?? false;
+        const source = options?.source ?? 'manual';
+        if (!title.trim()) {
+            setError('Title is required');
+            if (editingTaskId) {
+                setAutoSaveState(source === 'autosave' ? 'error' : 'idle');
+            }
+            return false;
+        }
+        const missingRequiredTaxonomies = taxonomies
+            .filter((taxonomy) => taxonomy.isRequired)
+            .filter((taxonomy) => {
+            const selected = formTaxonomies[taxonomy.id];
+            if (Array.isArray(selected)) {
+                return selected.filter((value) => String(value).trim().length > 0).length === 0;
+            }
+            return typeof selected !== 'string' && typeof selected !== 'number'
+                || String(selected).trim().length === 0;
+        })
+            .map((taxonomy) => taxonomy.label);
+        if (missingRequiredTaxonomies.length > 0) {
+            setError(`Required taxonomy values are missing: ${missingRequiredTaxonomies.join(', ')}`);
+            if (editingTaskId) {
+                setAutoSaveState(source === 'autosave' ? 'error' : 'idle');
+            }
+            return false;
+        }
+        if (editingTaskId) {
+            const existing = relationshipTasks.find((task) => task.id === editingTaskId);
+            if (existing?.isArchived) {
+                setError('Archived tasks are read-only. Unarchive first to make changes.');
+                setAutoSaveState(source === 'autosave' ? 'error' : 'idle');
+                return false;
+            }
+        }
+        setLoading(true);
+        setError('');
+        if (editingTaskId) {
+            setAutoSaveState('saving');
+        }
+        try {
+            const url = editingTaskId
+                ? `/api/taskforce/task/${editingTaskId}`
+                : apiEndpoint.replace('/api/dev/task', '/api/taskforce/task').replace('/api/taskforce/task', '/api/taskforce/task');
+            const method = editingTaskId ? 'PATCH' : 'POST';
+            const sanitizedCategory = typeof category === 'string'
+                ? category
+                : category.label || getPreferredCategoryValue(activeCategories);
+            const sanitizedType = typeof type === 'string' ? type : type.label || DEFAULT_TYPE_VALUE;
+            const resolvedWorkstream = workstreamInput.trim()
+                ? resolveWorkstreamIdInput(workstreamInput)
+                : null;
+            const body = {
+                title,
+                description: description || null,
+                category: sanitizedCategory || getPreferredCategoryValue(activeCategories),
+                type: sanitizedType,
+                priority,
+                complexity: Number(complexity) || 3,
+                status: editingTaskId ? undefined : status,
+                completedAt: editingTaskId ? undefined : (status === 'done' ? new Date().toISOString() : null),
+                approach: approach || 'default',
+                assignee: assignee || 'agent',
+                scheduledDate: scheduledDate || null,
+                dueDate: dueDate || null,
+                workstreamId: workstreamInput.trim()
+                    ? (resolvedWorkstream?.id || workstreamInput.trim())
+                    : null,
+                checklistItems,
+                comments,
+                taxonomies: formTaxonomies,
+                ...(!editingTaskId ? {
+                    createdAt: new Date().toISOString(),
+                    createdBy: 'user',
+                } : {}),
+            };
+            if (!editingTaskId || attachmentsDirty) {
+                body.attachments = attachments;
+            }
+            const res = await fetch(url, {
+                method,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                const data = await res.json();
+                const message = data.message || `Failed to ${editingTaskId ? 'update' : 'save'} task`;
+                setError(message);
+                if (!quiet) {
+                    pushNotice(message, 'error');
+                }
+                setLoading(false);
+                if (editingTaskId) {
+                    setAutoSaveState('error');
+                }
+                return false;
+            }
+            const updatedTask = await res.json().catch(() => null);
+            if (editingTaskId && updatedTask && typeof updatedTask === 'object') {
+                mergeTaskFromServer(updatedTask);
+                queueWorkspaceSyncFromAuthoritativeTaskState();
+            }
+            setLastUsedCategory(sanitizedCategory);
+            setAttachmentsDirty(false);
+            setLoading(false);
+            if (editingTaskId) {
+                setAutoSaveState('saved');
+            }
+            return true;
+        }
+        catch {
+            setError('Failed to connect to server');
+            if (!quiet) {
+                pushNotice('Failed to connect to server', 'error');
+            }
+            setLoading(false);
+            if (editingTaskId) {
+                setAutoSaveState('error');
+            }
+            return false;
+        }
+    }, [
+        activeCategories,
+        apiEndpoint,
+        approach,
+        assignee,
+        attachments,
+        attachmentsDirty,
+        category,
+        checklistItems,
+        comments,
+        complexity,
+        description,
+        dueDate,
+        editingTaskId,
+        formTaxonomies,
+        getPreferredCategoryValue,
+        mergeTaskFromServer,
+        workstreamInput,
+        priority,
+        pushNotice,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+        resolveWorkstreamIdInput,
+        setAttachmentsDirty,
+        setError,
+        setLastUsedCategory,
+        setLoading,
+        scheduledDate,
+        status,
+        title,
+        taxonomies,
+        type
+    ]);
+    const runSaveFlow = useCallback(async () => {
+        const success = await saveTask({ source: 'manual' });
+        if (success) {
+            if (!editingTaskId) {
+                pushNotice('Task added successfully', 'success');
+            }
+            if (activeTab === 'add' && !editingTaskId) {
+                resetForm();
+                setActiveTab('tasks');
+                await fetchTasks();
+            }
+        }
+    }, [activeTab, editingTaskId, fetchTasks, pushNotice, resetForm, saveTask, setActiveTab]);
+    useEffect(() => {
+        clearAutoSaveTimer();
+        if (!editingTaskId) {
+            setLastSavedDraftSignature(null);
+            setAutoSaveState('idle');
+            return;
+        }
+        setLastSavedDraftSignature(buildTaskDraftSignature());
+        setAutoSaveState('idle');
+    }, [clearAutoSaveTimer, editingTaskId]);
+    const flushAutoSave = useCallback(async () => {
+        clearAutoSaveTimer();
+        if (!editingTaskId || lastSavedDraftSignature === null) {
+            return;
+        }
+        const draftSignature = buildTaskDraftSignature();
+        if (draftSignature === lastSavedDraftSignature) {
+            return;
+        }
+        if (!title.trim() || (dueDate && scheduledDate && dueDate < scheduledDate)) {
+            return;
+        }
+        const success = await saveTask({ quiet: true, source: 'autosave' });
+        if (success) {
+            setLastSavedDraftSignature(draftSignature);
+        }
+    }, [
+        buildTaskDraftSignature,
+        clearAutoSaveTimer,
+        dueDate,
+        editingTaskId,
+        lastSavedDraftSignature,
+        saveTask,
+        scheduledDate,
+        title
+    ]);
+    useEffect(() => {
+        if (!editingTaskId || lastSavedDraftSignature === null) {
+            return;
+        }
+        const draftSignature = buildTaskDraftSignature();
+        if (draftSignature === lastSavedDraftSignature) {
+            return;
+        }
+        if (!title.trim()) {
+            setAutoSaveState('idle');
+            return;
+        }
+        if (dueDate && scheduledDate && dueDate < scheduledDate) {
+            setAutoSaveState('error');
+            return;
+        }
+        setAutoSaveState((current) => current === 'error' ? 'error' : 'idle');
+        clearAutoSaveTimer();
+        autoSaveTimerRef.current = window.setTimeout(async () => {
+            const success = await saveTask({ quiet: true, source: 'autosave' });
+            if (success) {
+                setLastSavedDraftSignature(draftSignature);
+            }
+        }, 700);
+        return () => {
+            clearAutoSaveTimer();
+        };
+    }, [
+        buildTaskDraftSignature,
+        clearAutoSaveTimer,
+        dueDate,
+        editingTaskId,
+        lastSavedDraftSignature,
+        saveTask,
+        scheduledDate,
+        title
+    ]);
+    const handleSubmit = useCallback(async (event) => {
+        event.preventDefault();
+        if (dueDate && scheduledDate && dueDate < scheduledDate) {
+            setScheduleWarningPrompt({ dueDate, scheduledDate });
+            return;
+        }
+        await runSaveFlow();
+    }, [dueDate, runSaveFlow, scheduledDate]);
+    const confirmScheduleWarning = useCallback(async () => {
+        setScheduleWarningPrompt(null);
+        await runSaveFlow();
+    }, [runSaveFlow]);
+    const cancelScheduleWarning = useCallback(() => {
+        setScheduleWarningPrompt(null);
+    }, []);
+    const handleAddComment = useCallback(async (text) => {
+        if (!editingTaskId || !text.trim())
+            return;
+        const nextText = text.trim();
+        try {
+            const res = await fetch(`/api/taskforce/task/${editingTaskId}/comment`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ text: nextText, author: 'user' })
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to add comment.';
+                setError(message);
+                pushNotice(message, 'error');
+                return;
+            }
+            const updatedTask = await res.json().catch(() => null);
+            setNewCommentText('');
+            if (updatedTask && typeof updatedTask === 'object') {
+                const normalizedTask = normalizeTaskFromApi(updatedTask);
+                setComments(normalizedTask.comments || []);
+                mergeTaskFromServer(updatedTask);
+                setLastSavedDraftSignature(buildTaskDraftSignature());
+                setAutoSaveState('saved');
+            }
+            else {
+                await fetchTasks(true);
+            }
+            queueWorkspaceSyncFromAuthoritativeTaskState();
+        }
+        catch (err) {
+            console.error('Failed to add comment', err);
+            setError('Failed to add comment.');
+            pushNotice('Failed to add comment.', 'error');
+        }
+    }, [
+        editingTaskId,
+        fetchTasks,
+        buildTaskDraftSignature,
+        mergeTaskFromServer,
+        pushNotice,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+        setComments,
+        setError,
+        setNewCommentText
+    ]);
+    return {
+        autoSaveState,
+        flushAutoSave,
+        scheduleWarningPrompt,
+        saveTask,
+        handleSubmit,
+        confirmScheduleWarning,
+        cancelScheduleWarning,
+        handleAddComment
+    };
+}

package/dist/hooks/tasks/useTaskRelationships.d.ts

@@ -0,0 +1,16 @@
+import type { TaskItem, WorkstreamItem } from '../../types';
+interface UseTaskRelationshipsInput {
+    editingTaskId: string | null;
+    mergeTaskFromServer: (task: unknown) => void;
+    workstreamInput: string;
+    pushNotice: (message: string, level?: 'success' | 'error' | 'info') => void;
+    queueWorkspaceSyncFromAuthoritativeTaskState: () => void;
+    relationshipTasks: TaskItem[];
+    resolveWorkstreamIdInput: (value: string) => WorkstreamItem | null;
+    setError: (value: string) => void;
+    fetchTasks: (isSilent?: boolean) => Promise<void>;
+}
+export declare function useTaskRelationships(input: UseTaskRelationshipsInput): {
+    handleSetWorkstreamForCurrentTask: (workstreamIdOverride?: string | null) => Promise<void>;
+};
+export {};

package/dist/hooks/tasks/useTaskRelationships.js

@@ -0,0 +1,64 @@
+import { useCallback } from 'react';
+export function useTaskRelationships(input) {
+    const { editingTaskId, fetchTasks, mergeTaskFromServer, workstreamInput, pushNotice, queueWorkspaceSyncFromAuthoritativeTaskState, relationshipTasks, resolveWorkstreamIdInput, setError } = input;
+    const handleSetWorkstreamForCurrentTask = useCallback(async (workstreamIdOverride) => {
+        if (!editingTaskId)
+            return;
+        const current = relationshipTasks.find((task) => task.id === editingTaskId);
+        if (!current)
+            return;
+        const nextWorkstreamRaw = typeof workstreamIdOverride === 'string'
+            ? workstreamIdOverride.trim()
+            : workstreamIdOverride === null
+                ? ''
+                : workstreamInput.trim();
+        const resolvedWorkstream = nextWorkstreamRaw ? resolveWorkstreamIdInput(nextWorkstreamRaw) : null;
+        const normalizedWorkstreamId = nextWorkstreamRaw.length > 0 ? (resolvedWorkstream?.id || nextWorkstreamRaw) : null;
+        if ((current.workstreamId || null) === normalizedWorkstreamId) {
+            pushNotice(normalizedWorkstreamId ? 'Task already belongs to that workstream.' : 'Task is already standalone.', 'info');
+            return;
+        }
+        try {
+            const res = await fetch(`/api/taskforce/task/${editingTaskId}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ workstreamId: normalizedWorkstreamId })
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to set workstream.';
+                setError(message);
+                pushNotice(message, 'error');
+                return;
+            }
+            setError('');
+            pushNotice(normalizedWorkstreamId ? 'Workstream set' : 'Workstream removed', 'info');
+            const updatedTask = await res.json().catch(() => null);
+            if (updatedTask) {
+                mergeTaskFromServer(updatedTask);
+                queueWorkspaceSyncFromAuthoritativeTaskState();
+            }
+            else {
+                await fetchTasks(true);
+                queueWorkspaceSyncFromAuthoritativeTaskState();
+            }
+        }
+        catch {
+            setError('Failed to set workstream.');
+            pushNotice('Failed to set workstream.', 'error');
+        }
+    }, [
+        editingTaskId,
+        fetchTasks,
+        mergeTaskFromServer,
+        workstreamInput,
+        pushNotice,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+        relationshipTasks,
+        resolveWorkstreamIdInput,
+        setError
+    ]);
+    return {
+        handleSetWorkstreamForCurrentTask
+    };
+}

package/dist/hooks/ui/useResourceExport.d.ts

@@ -0,0 +1,19 @@
+import type { Environment } from '../../types';
+interface UseResourceExportInput {
+    storagePath: string;
+}
+export declare function useResourceExport({ storagePath }: UseResourceExportInput): {
+    exportEnvironment: string;
+    setExportEnvironment: import("react").Dispatch<import("react").SetStateAction<string>>;
+    availableEnvironments: Environment[];
+    loadAvailableEnvironments: () => Promise<void>;
+    exportWorkflowsPath: string;
+    setExportWorkflowsPath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    exportingResource: "workflows" | null;
+    exportResult: {
+        type: "success" | "error";
+        message: string;
+    } | null;
+    handleExportWorkflows: (environment: string, selected: string[]) => Promise<void>;
+};
+export {};

package/dist/hooks/ui/useResourceExport.js

@@ -0,0 +1,84 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+export function useResourceExport({ storagePath }) {
+    const [exportEnvironment, setExportEnvironment] = useState('antigravity');
+    const [availableEnvironments, setAvailableEnvironments] = useState([]);
+    const [exportWorkflowsPath, setExportWorkflowsPath] = useState('.agent/workflows');
+    const [exportingResource, setExportingResource] = useState(null);
+    const [exportResult, setExportResult] = useState(null);
+    const exportResultTimerRef = useRef(null);
+    useEffect(() => {
+        const env = availableEnvironments.find((item) => item.id === exportEnvironment);
+        if (env) {
+            setExportWorkflowsPath(env.directory);
+        }
+    }, [exportEnvironment, availableEnvironments]);
+    const clearExportResultLater = useCallback(() => {
+        if (typeof window === 'undefined')
+            return;
+        if (exportResultTimerRef.current !== null)
+            window.clearTimeout(exportResultTimerRef.current);
+        exportResultTimerRef.current = window.setTimeout(() => {
+            exportResultTimerRef.current = null;
+            setExportResult(null);
+        }, 5000);
+    }, []);
+    const loadAvailableEnvironments = useCallback(async () => {
+        const envRes = await fetch('/api/taskforce/environments');
+        if (!envRes.ok)
+            return;
+        const envData = await envRes.json().catch(() => ({}));
+        if (envData.environments)
+            setAvailableEnvironments(envData.environments);
+    }, []);
+    const handleExportWorkflows = useCallback(async (environment, selected) => {
+        setExportingResource('workflows');
+        setExportResult(null);
+        try {
+            const res = await fetch('/api/taskforce/export-resources', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    type: 'workflows',
+                    environment,
+                    workflowNames: selected,
+                    variables: {
+                        STORAGE_PATH: storagePath.replace(/\/$/, '') || '.Taskforce'
+                    }
+                })
+            });
+            const data = await res.json();
+            if (data.success) {
+                setExportResult({ type: 'success', message: `Successfully exported ${data.count} workflows to ${environment}` });
+            }
+            else {
+                setExportResult({ type: 'error', message: data.error || 'Export failed' });
+            }
+        }
+        catch {
+            setExportResult({ type: 'error', message: 'Network error exporting workflows' });
+        }
+        finally {
+            setExportingResource(null);
+            clearExportResultLater();
+        }
+    }, [clearExportResultLater, storagePath]);
+    useEffect(() => {
+        return () => {
+            if (exportResultTimerRef.current !== null && typeof window !== 'undefined') {
+                window.clearTimeout(exportResultTimerRef.current);
+                exportResultTimerRef.current = null;
+            }
+        };
+    }, []);
+    return {
+        exportEnvironment,
+        setExportEnvironment,
+        availableEnvironments,
+        loadAvailableEnvironments,
+        exportWorkflowsPath,
+        setExportWorkflowsPath,
+        exportingResource,
+        exportResult,
+        handleExportWorkflows
+    };
+}