@taskforcehq/taskforce 0.3.304 → 0.3.306

package/scripts/migrate-planning-model.ts

@@ -1,233 +0,0 @@
-import { TaskforceCore } from '../src/core/Taskforce.js';
-import type { ChecklistItem, TaskItem } from '../src/types.js';
-import { collectSubtreeTaskIds } from '../src/utils/taskHierarchy.js';
-
-type MigrationOptions = {
-    workspaceId: string | null;
-    all: boolean;
-    dryRun: boolean;
-};
-
-type WorkspaceMigrationSummary = {
-    workspaceId: string;
-    rootParentCount: number;
-    descendantTaskCount: number;
-    createdWorkstreams: number;
-    deletedRootTasks: number;
-    updatedTasks: number;
-};
-
-type LegacyTaskRow = TaskItem & { isArchived?: boolean };
-
-function readFlag(name: string): string | null {
-    const prefix = `${name}=`;
-    const match = process.argv.find((arg) => arg.startsWith(prefix));
-    return match ? match.slice(prefix.length) : null;
-}
-
-function parseArgs(): MigrationOptions {
-    const workspaceId = (readFlag('--workspace') || '').trim() || null;
-    const all = process.argv.includes('--all');
-    const dryRun = process.argv.includes('--dry-run');
-    if (workspaceId && all) {
-        throw new Error('Use either --workspace=<id> or --all, not both.');
-    }
-    return { workspaceId, all, dryRun };
-}
-
-function normalizeOwnerId(task: TaskItem): string | null {
-    const raw = String(task.assignee || '').trim();
-    if (!raw || raw === 'unassigned') return null;
-    return raw;
-}
-
-function checklistItemsToDescription(checklistItems: ChecklistItem[] | undefined, baseDescription: string | null | undefined): string | null {
-    const items = Array.isArray(checklistItems) ? checklistItems : [];
-    if (items.length === 0) return typeof baseDescription === 'string' && baseDescription.trim() ? baseDescription : null;
-    const checklistText = items
-        .sort((left, right) => Number(left.order || 0) - Number(right.order || 0))
-        .map((item) => `- [${item.isCompleted ? 'x' : ' '}] ${item.title}`)
-        .join('\n');
-    const trimmedBase = String(baseDescription || '').trim();
-    return [trimmedBase, 'Former checklist', checklistText].filter(Boolean).join('\n\n');
-}
-
-function listWorkspaceIds(core: TaskforceCore): string[] {
-    const preferred = core.resolvePreferredWorkspaceId({ allowDefault: true });
-    const db = (core as any).db;
-    const tenantId = core.getPaths().tenantId;
-    const rows = db.prepare(`
-        SELECT id
-        FROM workspaces
-        WHERE tenant_id = ?
-        ORDER BY created_at ASC
-    `).all(tenantId) as Array<{ id?: string }>;
-    const ids = rows
-        .map((row) => String(row.id || '').trim())
-        .filter(Boolean);
-    if (ids.length > 0) return ids;
-    return [preferred || 'default'];
-}
-
-function listAllTasksForWorkspace(core: TaskforceCore, workspaceId: string): LegacyTaskRow[] {
-    const active = core.listTasks(workspaceId).tasks;
-    const archived = core.listArchive(workspaceId).archived;
-    return [...active, ...archived];
-}
-
-function migrateWorkspace(core: TaskforceCore, workspaceId: string, dryRun: boolean): WorkspaceMigrationSummary {
-    const existingInitiatives = core.listInitiatives(workspaceId);
-    const existingWorkstreams = core.listWorkstreams(workspaceId);
-    if (existingInitiatives.length > 0 || existingWorkstreams.length > 0) {
-        throw new Error(
-            `Workspace ${workspaceId} already has planning entities (${existingInitiatives.length} initiatives, ${existingWorkstreams.length} workstreams). Aborting.`
-        );
-    }
-
-    const allTasks = listAllTasksForWorkspace(core, workspaceId);
-    const childrenByParent = new Map<string, LegacyTaskRow[]>();
-    const tasksById = new Map<string, LegacyTaskRow>();
-    for (const task of allTasks) {
-        tasksById.set(task.id, task);
-        const parentId = String(task.parentTaskId || '').trim();
-        if (!parentId) continue;
-        const list = childrenByParent.get(parentId) || [];
-        list.push(task);
-        childrenByParent.set(parentId, list);
-    }
-
-    const rootParents = allTasks.filter((task) => {
-        if (!childrenByParent.has(task.id)) return false;
-        const parentId = String(task.parentTaskId || '').trim();
-        return !parentId || !tasksById.has(parentId);
-    });
-
-    const summary: WorkspaceMigrationSummary = {
-        workspaceId,
-        rootParentCount: rootParents.length,
-        descendantTaskCount: 0,
-        createdWorkstreams: 0,
-        deletedRootTasks: 0,
-        updatedTasks: 0,
-    };
-
-    if (rootParents.length === 0) {
-        return summary;
-    }
-
-    const db = (core as any).db;
-    const tenantId = core.getPaths().tenantId;
-    const descendantsByRoot = new Map<string, LegacyTaskRow[]>();
-
-    for (const root of rootParents) {
-        const descendantIds = [...collectSubtreeTaskIds(allTasks, root.id)].filter((id) => id !== root.id);
-        const descendants = descendantIds
-            .map((id) => tasksById.get(id))
-            .filter((task): task is LegacyTaskRow => Boolean(task));
-        descendantsByRoot.set(root.id, descendants);
-        summary.descendantTaskCount += descendants.length;
-    }
-
-    summary.createdWorkstreams = rootParents.length;
-    summary.updatedTasks = summary.descendantTaskCount;
-    summary.deletedRootTasks = rootParents.length;
-
-    const mutate = () => {
-        for (const root of rootParents) {
-            const descendants = descendantsByRoot.get(root.id) || [];
-
-            const workstream = core.createWorkstream({
-                title: root.title,
-                description: checklistItemsToDescription(root.checklistItems, root.description),
-                ownerId: normalizeOwnerId(root),
-                referenceNumber: root.referenceNumber ?? undefined,
-                createdAt: root.createdAt,
-                updatedAt: root.updatedAt,
-                isArchived: Boolean(root.isArchived),
-                comments: root.comments || [],
-                attachments: root.attachments || [],
-            }, workspaceId);
-
-            for (const descendant of descendants) {
-                const nextUpdatedAt = new Date().toISOString();
-                db.prepare(`
-                    UPDATE tasks
-                    SET parent_task_id = NULL,
-                        child_display_order = NULL,
-                        workstream_id = @workstreamId,
-                        updated_at = @updatedAt
-                    WHERE tenant_id = @tenantId
-                      AND workspace_id = @workspaceId
-                      AND id = @id
-                `).run({
-                    id: descendant.id,
-                    tenantId,
-                    workspaceId,
-                    workstreamId: workstream.id,
-                    updatedAt: nextUpdatedAt,
-                });
-            }
-
-            // Clear canonical attachment links tied to the legacy parent task before deleting it.
-            (core as any).syncCanonicalTaskAttachmentLinks(root.id, workspaceId, []);
-
-            db.prepare(`
-                DELETE FROM tasks
-                WHERE tenant_id = @tenantId
-                  AND workspace_id = @workspaceId
-                  AND id = @id
-            `).run({
-                id: root.id,
-                tenantId,
-                workspaceId,
-            });
-        }
-
-        (core as any).persistBackup?.();
-    };
-
-    if (!dryRun) {
-        db.transaction(mutate)();
-    }
-
-    return summary;
-}
-
-function printSummary(summary: WorkspaceMigrationSummary): void {
-    console.log([
-        `workspace=${summary.workspaceId}`,
-        `rootParents=${summary.rootParentCount}`,
-        `descendants=${summary.descendantTaskCount}`,
-        `workstreamsCreated=${summary.createdWorkstreams}`,
-        `tasksUpdated=${summary.updatedTasks}`,
-        `rootTasksDeleted=${summary.deletedRootTasks}`,
-    ].join(' '));
-}
-
-async function main() {
-    const options = parseArgs();
-    const core = new TaskforceCore({
-        projectRoot: process.cwd(),
-        runtimeMode: 'local',
-        storagePath: '.taskforce',
-    });
-
-    try {
-        const workspaceIds = options.all
-            ? listWorkspaceIds(core)
-            : [options.workspaceId || core.resolvePreferredWorkspaceId({ allowDefault: true }) || 'default'];
-
-        console.log(`[planning-migration] mode=${options.dryRun ? 'dry-run' : 'apply'} workspaces=${workspaceIds.join(',')}`);
-        for (const workspaceId of workspaceIds) {
-            const summary = migrateWorkspace(core, workspaceId, options.dryRun);
-            printSummary(summary);
-        }
-    } finally {
-        core.close();
-    }
-}
-
-main().catch((error) => {
-    console.error(`[planning-migration] ${String((error as Error)?.message || error)}`);
-    process.exit(1);
-});