@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/TaskforceWidget.js

@@ -3,6 +3,7 @@ import { useState, useEffect, useCallback, useRef } from 'react';
 import { ClipboardList } from 'lucide-react';
 import { TaskforceCore } from './TaskforceCore';
 import styles from './Taskforce.module.css';
+import shellStyles from './components/views/WorkspaceShell.module.css';
 import { DEFAULT_CONFIG } from './types';
 export const TaskforceWidget = ({ config = {} }) => {
     const mergedConfig = { ...DEFAULT_CONFIG, ...config };
@@ -93,9 +94,9 @@ export const TaskforceWidget = ({ config = {} }) => {
     if (!import.meta.env.DEV) {
         return null;
     }
-    return (_jsxs(_Fragment, { children: [_jsxs("button", { className: styles.floatingButton, onClick: () => setIsOpen(!isOpen), title: `Taskforce (${configShortcut})`, children: [_jsx(ClipboardList, { size: 22 }), taskCount > 0 && (_jsx("span", { className: styles.badge, children: taskCount }))] }), _jsx("div", { id: "taskforce-root", className: `${styles.overlay} ${styles.widgetOverlay}`, style: {
+    return (_jsxs(_Fragment, { children: [_jsxs("button", { className: styles.floatingButton, onClick: () => setIsOpen(!isOpen), title: `Taskforce (${configShortcut})`, children: [_jsx(ClipboardList, { size: 22 }), taskCount > 0 && (_jsx("span", { className: styles.badge, children: taskCount }))] }), _jsx("div", { id: "taskforce-root", className: `${styles.overlay} ${shellStyles.widgetOverlay}`, style: {
                     display: isOpen ? 'flex' : 'none',
-                }, children: _jsx("div", { ref: modalRef, className: `${styles.modal} ${styles.widgetModal}`, style: {
+                }, children: _jsx("div", { ref: modalRef, className: `${styles.modal} ${shellStyles.widgetModal}`, style: {
                         transform: `translate(${position.x}px, ${position.y}px)`,
                     }, children: _jsx(TaskforceCore, { config: config, mode: "standalone", onHeaderMouseDown: handleMouseDown, isDragging: isDragging, onTaskCountChange: setTaskCount, onClose: () => setIsOpen(false) }) }) })] }));
 };

package/dist/__tests__/localizationCatalogs.test.js

@@ -1,37 +1,54 @@
-import { describe, expect, it } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { enUS } from '../localization/locales/en-US';
 import { es419 } from '../localization/locales/es-419';
 import { ptBR } from '../localization/locales/pt-BR';
-function collectLeafKeys(input, prefix = '') {
-    if (!input || typeof input !== 'object')
-        return [];
-    return Object.entries(input).flatMap(([key, value]) => {
-        const nextPrefix = prefix ? `${prefix}.${key}` : key;
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-            return collectLeafKeys(value, nextPrefix);
+const NON_DEFAULT_LOCALES = [
+    { name: 'es-419', catalog: es419 },
+    { name: 'pt-BR', catalog: ptBR }
+];
+function collectLeafPaths(obj, prefix = '') {
+    const paths = [];
+    for (const [key, value] of Object.entries(obj)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'object' && value !== null) {
+            paths.push(...collectLeafPaths(value, path));
         }
-        return [nextPrefix];
-    });
-}
-describe('Localization catalogs', () => {
-    it('keeps identical key coverage across locales', () => {
-        const enKeys = collectLeafKeys(enUS).sort();
-        const esKeys = collectLeafKeys(es419).sort();
-        const ptKeys = collectLeafKeys(ptBR).sort();
-        expect(esKeys).toEqual(enKeys);
-        expect(ptKeys).toEqual(enKeys);
-    });
-    it('avoids blank translations in non-default locales', () => {
-        const values = [es419, ptBR];
-        for (const catalog of values) {
-            for (const key of collectLeafKeys(catalog)) {
-                const segments = key.split('.');
-                let cursor = catalog;
-                for (const segment of segments)
-                    cursor = cursor?.[segment];
-                expect(typeof cursor).toBe('string');
-                expect(String(cursor).trim().length).toBeGreaterThan(0);
-            }
+        else {
+            paths.push(path);
         }
-    });
+    }
+    return paths;
+}
+function getByPath(obj, path) {
+    return path.split('.').reduce((cur, part) => {
+        if (cur && typeof cur === 'object')
+            return cur[part];
+        return undefined;
+    }, obj);
+}
+const enUSPaths = collectLeafPaths(enUS);
+describe('Localization catalog parity', () => {
+    for (const { name, catalog } of NON_DEFAULT_LOCALES) {
+        describe(`${name}`, () => {
+            it('has all keys present in en-US', () => {
+                const missingKeys = [];
+                for (const path of enUSPaths) {
+                    if (getByPath(catalog, path) === undefined) {
+                        missingKeys.push(path);
+                    }
+                }
+                expect(missingKeys, `Missing keys in ${name}: ${missingKeys.join(', ')}`).toHaveLength(0);
+            });
+            it('has no empty string values', () => {
+                const emptyKeys = [];
+                const paths = collectLeafPaths(catalog);
+                for (const path of paths) {
+                    if (getByPath(catalog, path) === '') {
+                        emptyKeys.push(path);
+                    }
+                }
+                expect(emptyKeys, `Empty values in ${name}: ${emptyKeys.join(', ')}`).toHaveLength(0);
+            });
+        });
+    }
 });

package/dist/__tests__/workflowSimulation.test.js

@@ -68,7 +68,7 @@ function simulateOptionalArtifactSave(workflowName, approveSave) {
     calls.push({ tool: 'prompt_save_artifact', args: { path: artifact.path } });
     if (approveSave) {
         calls.push({ tool: 'write_file', args: { path: artifact.path } });
-        calls.push({ tool: 'attach_context_file', args: { path: artifact.path } });
+        calls.push({ tool: 'link_task_context', args: { path: artifact.path } });
     }
     return calls;
 }
@@ -108,6 +108,6 @@ describe('Workflow simulation', () => {
         const noSave = simulateOptionalArtifactSave('evaluate', false);
         expect(noSave.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact']);
         const saved = simulateOptionalArtifactSave('evaluate', true);
-        expect(saved.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact', 'write_file', 'attach_context_file']);
+        expect(saved.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact', 'write_file', 'link_task_context']);
     });
 });

package/dist/annotatedAttachments/AnnotatedAttachmentSessionStore.d.ts

@@ -0,0 +1,60 @@
+import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
+import type { AnnotatedAttachmentAnnotation, AnnotatedAttachmentSessionRecord } from './types.js';
+export declare class AnnotatedAttachmentSessionStore {
+    private readonly db;
+    private readonly tenantId;
+    constructor(db: DatabaseAdapter, tenantId: string);
+    listForTask(taskIdRaw: string, workspaceIdRaw: string, options?: {
+        imageAssetId?: string | null;
+        includeDeleted?: boolean;
+        includeUnattached?: boolean;
+    }): AnnotatedAttachmentSessionRecord[];
+    listByImageAsset(imageAssetIdRaw: string, workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+    }): AnnotatedAttachmentSessionRecord[];
+    listByWorkspace(workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+    }): AnnotatedAttachmentSessionRecord[];
+    get(sessionIdRaw: string, workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+    }): AnnotatedAttachmentSessionRecord | null;
+    create(input: {
+        id: string;
+        workspaceId: string;
+        taskId: string;
+        baseImageAssetId: string;
+        title?: string | null;
+        globalInstruction?: string | null;
+        annotations?: AnnotatedAttachmentAnnotation[];
+        createdByActorId?: string | null;
+        updatedByActorId?: string | null;
+        createdAt?: string;
+        updatedAt?: string;
+    }): AnnotatedAttachmentSessionRecord;
+    upsertForSync(input: {
+        id: string;
+        workspaceId: string;
+        taskId: string;
+        baseImageAssetId: string;
+        title?: string | null;
+        globalInstruction?: string | null;
+        annotations?: AnnotatedAttachmentAnnotation[];
+        createdByActorId?: string | null;
+        updatedByActorId?: string | null;
+        createdAt?: string;
+        updatedAt?: string;
+        deletedAt?: string | null;
+    }): AnnotatedAttachmentSessionRecord;
+    update(input: {
+        id: string;
+        workspaceId: string;
+        title?: string | null;
+        globalInstruction?: string | null;
+        annotations?: AnnotatedAttachmentAnnotation[];
+        updatedByActorId?: string | null;
+        updatedAt?: string;
+    }): AnnotatedAttachmentSessionRecord | null;
+    softDelete(sessionIdRaw: string, workspaceIdRaw: string, deletedAtRaw?: string): boolean;
+    softDeleteByImageAsset(imageAssetIdRaw: string, workspaceIdRaw: string, deletedAtRaw?: string): number;
+    softDeleteByTaskAndImage(taskIdRaw: string, imageAssetIdRaw: string, workspaceIdRaw: string, deletedAtRaw?: string): number;
+}

package/dist/annotatedAttachments/AnnotatedAttachmentSessionStore.js

@@ -0,0 +1,324 @@
+function normalizeId(value) {
+    return String(value || '').trim();
+}
+function normalizeWorkspaceId(value) {
+    return normalizeId(value) || 'default';
+}
+function normalizeNullable(value) {
+    const normalized = String(value || '').trim();
+    return normalized || null;
+}
+function normalizeMarkerType(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'question'
+        || normalized === 'change'
+        || normalized === 'issue'
+        || normalized === 'idea'
+        || normalized === 'review') {
+        return normalized;
+    }
+    return undefined;
+}
+function clamp01(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric))
+        return 0;
+    if (numeric <= 0)
+        return 0;
+    if (numeric >= 1)
+        return 1;
+    return numeric;
+}
+function normalizeInteger(value, fallback = 0) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric))
+        return fallback;
+    return Math.max(0, Math.floor(numeric));
+}
+function normalizeAnnotation(raw, index) {
+    const record = raw && typeof raw === 'object' ? raw : null;
+    if (!record)
+        return null;
+    const kind = String(record.kind || '').trim().toLowerCase();
+    const base = {
+        id: normalizeId(record.id) || `annotation-${index + 1}`,
+        order: normalizeInteger(record.order, index),
+        markerType: normalizeMarkerType(record.markerType),
+        instruction: normalizeId(record.instruction),
+        color: normalizeNullable(record.color),
+    };
+    if (kind === 'pin') {
+        return { ...base, kind: 'pin', x: clamp01(record.x), y: clamp01(record.y) };
+    }
+    if (kind === 'arrow') {
+        return {
+            ...base,
+            kind: 'arrow',
+            x: clamp01(record.x),
+            y: clamp01(record.y),
+            x2: clamp01(record.x2),
+            y2: clamp01(record.y2),
+        };
+    }
+    if (kind === 'box') {
+        return {
+            ...base,
+            kind: 'box',
+            x: clamp01(record.x),
+            y: clamp01(record.y),
+            width: clamp01(record.width),
+            height: clamp01(record.height),
+        };
+    }
+    if (kind === 'text-note') {
+        return { ...base, kind: 'text-note', x: clamp01(record.x), y: clamp01(record.y) };
+    }
+    return null;
+}
+function parseAnnotations(value) {
+    const rawJson = typeof value === 'string' ? value : '';
+    if (!rawJson)
+        return [];
+    try {
+        const parsed = JSON.parse(rawJson);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .map((entry, index) => normalizeAnnotation(entry, index))
+            .filter((entry) => Boolean(entry))
+            .sort((left, right) => left.order - right.order || left.id.localeCompare(right.id));
+    }
+    catch {
+        return [];
+    }
+}
+function mapRow(row) {
+    return {
+        id: normalizeId(row.id),
+        tenantId: normalizeId(row.tenant_id) || 'default',
+        workspaceId: normalizeWorkspaceId(row.workspace_id),
+        taskId: normalizeId(row.task_id),
+        baseImageAssetId: normalizeId(row.base_image_asset_id),
+        title: normalizeNullable(row.title),
+        globalInstruction: normalizeNullable(row.global_instruction),
+        annotations: parseAnnotations(row.annotations_json),
+        createdByActorId: normalizeNullable(row.created_by_actor_id),
+        updatedByActorId: normalizeNullable(row.updated_by_actor_id),
+        createdAt: normalizeId(row.created_at),
+        updatedAt: normalizeId(row.updated_at),
+        deletedAt: normalizeNullable(row.deleted_at),
+    };
+}
+export class AnnotatedAttachmentSessionStore {
+    db;
+    tenantId;
+    constructor(db, tenantId) {
+        this.db = db;
+        this.tenantId = tenantId;
+    }
+    listForTask(taskIdRaw, workspaceIdRaw, options) {
+        const taskId = normalizeId(taskIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!taskId)
+            return [];
+        const includeDeleted = options?.includeDeleted === true;
+        const imageAssetId = normalizeNullable(options?.imageAssetId);
+        const includeUnattached = options?.includeUnattached === true && !!imageAssetId;
+        const taskFilter = includeUnattached ? "(task_id = ? OR task_id = '')" : 'task_id = ?';
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM annotated_attachment_sessions
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND ${taskFilter}
+              ${imageAssetId ? 'AND base_image_asset_id = ?' : ''}
+              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+            ORDER BY updated_at DESC, created_at DESC, id ASC
+        `).all(...(imageAssetId
+            ? [this.tenantId, workspaceId, taskId, imageAssetId]
+            : [this.tenantId, workspaceId, taskId]));
+        return rows.map(mapRow);
+    }
+    listByImageAsset(imageAssetIdRaw, workspaceIdRaw, options) {
+        const imageAssetId = normalizeId(imageAssetIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!imageAssetId)
+            return [];
+        const includeDeleted = options?.includeDeleted === true;
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM annotated_attachment_sessions
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND base_image_asset_id = ?
+              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+            ORDER BY updated_at DESC, created_at DESC, id ASC
+        `).all(this.tenantId, workspaceId, imageAssetId);
+        return rows.map(mapRow);
+    }
+    listByWorkspace(workspaceIdRaw, options) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const includeDeleted = options?.includeDeleted === true;
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM annotated_attachment_sessions
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+            ORDER BY updated_at DESC, created_at DESC, id ASC
+        `).all(this.tenantId, workspaceId);
+        return rows.map(mapRow);
+    }
+    get(sessionIdRaw, workspaceIdRaw, options) {
+        const sessionId = normalizeId(sessionIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!sessionId)
+            return null;
+        const includeDeleted = options?.includeDeleted === true;
+        const row = this.db.prepare(`
+            SELECT *
+            FROM annotated_attachment_sessions
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND id = ?
+              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+            LIMIT 1
+        `).get(this.tenantId, workspaceId, sessionId);
+        return row ? mapRow(row) : null;
+    }
+    create(input) {
+        const id = normalizeId(input.id);
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const createdAt = normalizeId(input.createdAt) || new Date().toISOString();
+        const updatedAt = normalizeId(input.updatedAt) || createdAt;
+        this.db.prepare(`
+            INSERT INTO annotated_attachment_sessions (
+                id,
+                tenant_id,
+                workspace_id,
+                task_id,
+                base_image_asset_id,
+                title,
+                global_instruction,
+                annotations_json,
+                created_by_actor_id,
+                updated_by_actor_id,
+                created_at,
+                updated_at,
+                deleted_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
+        `).run(id, this.tenantId, workspaceId, normalizeId(input.taskId), normalizeId(input.baseImageAssetId), normalizeNullable(input.title), normalizeNullable(input.globalInstruction), JSON.stringify(Array.isArray(input.annotations) ? input.annotations : []), normalizeNullable(input.createdByActorId), normalizeNullable(input.updatedByActorId), createdAt, updatedAt);
+        return this.get(id, workspaceId, { includeDeleted: true });
+    }
+    upsertForSync(input) {
+        const id = normalizeId(input.id);
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const existing = this.get(id, workspaceId, { includeDeleted: true });
+        if (!existing) {
+            this.db.prepare(`
+                INSERT INTO annotated_attachment_sessions (
+                    id,
+                    tenant_id,
+                    workspace_id,
+                    task_id,
+                    base_image_asset_id,
+                    title,
+                    global_instruction,
+                    annotations_json,
+                    created_by_actor_id,
+                    updated_by_actor_id,
+                    created_at,
+                    updated_at,
+                    deleted_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(id, this.tenantId, workspaceId, normalizeId(input.taskId), normalizeId(input.baseImageAssetId), normalizeNullable(input.title), normalizeNullable(input.globalInstruction), JSON.stringify(Array.isArray(input.annotations) ? input.annotations : []), normalizeNullable(input.createdByActorId), normalizeNullable(input.updatedByActorId), normalizeId(input.createdAt) || new Date().toISOString(), normalizeId(input.updatedAt) || normalizeId(input.createdAt) || new Date().toISOString(), normalizeNullable(input.deletedAt));
+            return this.get(id, workspaceId, { includeDeleted: true });
+        }
+        this.db.prepare(`
+            UPDATE annotated_attachment_sessions
+            SET task_id = ?,
+                base_image_asset_id = ?,
+                title = ?,
+                global_instruction = ?,
+                annotations_json = ?,
+                created_by_actor_id = ?,
+                updated_by_actor_id = ?,
+                created_at = ?,
+                updated_at = ?,
+                deleted_at = ?
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND id = ?
+        `).run(normalizeId(input.taskId) || existing.taskId, normalizeId(input.baseImageAssetId) || existing.baseImageAssetId, normalizeNullable(input.title), normalizeNullable(input.globalInstruction), JSON.stringify(Array.isArray(input.annotations) ? input.annotations : []), normalizeNullable(input.createdByActorId), normalizeNullable(input.updatedByActorId), normalizeId(input.createdAt) || existing.createdAt, normalizeId(input.updatedAt) || existing.updatedAt, normalizeNullable(input.deletedAt), this.tenantId, workspaceId, id);
+        return this.get(id, workspaceId, { includeDeleted: true });
+    }
+    update(input) {
+        const existing = this.get(input.id, input.workspaceId);
+        if (!existing)
+            return null;
+        const updatedAt = normalizeId(input.updatedAt) || new Date().toISOString();
+        this.db.prepare(`
+            UPDATE annotated_attachment_sessions
+            SET title = ?,
+                global_instruction = ?,
+                annotations_json = ?,
+                updated_by_actor_id = ?,
+                updated_at = ?
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND id = ?
+              AND deleted_at IS NULL
+        `).run(input.title === undefined ? existing.title : normalizeNullable(input.title), input.globalInstruction === undefined ? existing.globalInstruction : normalizeNullable(input.globalInstruction), JSON.stringify(input.annotations === undefined ? existing.annotations : input.annotations), input.updatedByActorId === undefined ? existing.updatedByActorId : normalizeNullable(input.updatedByActorId), updatedAt, this.tenantId, normalizeWorkspaceId(input.workspaceId), normalizeId(input.id));
+        return this.get(input.id, input.workspaceId);
+    }
+    softDelete(sessionIdRaw, workspaceIdRaw, deletedAtRaw) {
+        const sessionId = normalizeId(sessionIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!sessionId)
+            return false;
+        const deletedAt = normalizeId(deletedAtRaw) || new Date().toISOString();
+        const result = this.db.prepare(`
+            UPDATE annotated_attachment_sessions
+            SET deleted_at = ?, updated_at = ?
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND id = ?
+              AND deleted_at IS NULL
+        `).run(deletedAt, deletedAt, this.tenantId, workspaceId, sessionId);
+        return Number(result?.changes || 0) > 0;
+    }
+    softDeleteByImageAsset(imageAssetIdRaw, workspaceIdRaw, deletedAtRaw) {
+        const imageAssetId = normalizeId(imageAssetIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!imageAssetId)
+            return 0;
+        const deletedAt = normalizeId(deletedAtRaw) || new Date().toISOString();
+        const result = this.db.prepare(`
+            UPDATE annotated_attachment_sessions
+            SET deleted_at = ?, updated_at = ?
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND base_image_asset_id = ?
+              AND deleted_at IS NULL
+        `).run(deletedAt, deletedAt, this.tenantId, workspaceId, imageAssetId);
+        return Number(result?.changes || 0);
+    }
+    softDeleteByTaskAndImage(taskIdRaw, imageAssetIdRaw, workspaceIdRaw, deletedAtRaw) {
+        const taskId = normalizeId(taskIdRaw);
+        const imageAssetId = normalizeId(imageAssetIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!taskId || !imageAssetId)
+            return 0;
+        const deletedAt = normalizeId(deletedAtRaw) || new Date().toISOString();
+        const result = this.db.prepare(`
+            UPDATE annotated_attachment_sessions
+            SET deleted_at = ?, updated_at = ?
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND task_id = ?
+              AND base_image_asset_id = ?
+              AND deleted_at IS NULL
+        `).run(deletedAt, deletedAt, this.tenantId, workspaceId, taskId, imageAssetId);
+        return Number(result?.changes || 0);
+    }
+}