@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/apps/client/src/components/chat/session-timeline-panel/gantt.js

@@ -0,0 +1,148 @@
+import { normalizeTime, parseTime } from './utils';
+function createGanttItemIdFactory() {
+    let seq = 0;
+    return (prefix) => `${prefix}_${seq++}`;
+}
+function collectGanttItems(task, labels) {
+    const nextId = createGanttItemIdFactory();
+    const nextSectionId = createGanttItemIdFactory();
+    const interactions = [];
+    const items = [];
+    const blankSectionLabel = '\u200B';
+    let blankSectionSequence = 0;
+    const nextBlankSectionLabel = () => {
+        blankSectionSequence += 1;
+        return blankSectionLabel.repeat(blankSectionSequence);
+    };
+    const addInteraction = (interaction) => {
+        interactions.push(interaction);
+    };
+    const collectTaskSegments = (taskItem) => {
+        const segments = [
+            { start: taskItem.startTime, end: taskItem.endTime }
+        ];
+        const events = taskItem.events ?? [];
+        const askIndex = events.findIndex((event) => event.type === 'tool__AskUserQuestion');
+        if (askIndex < 0)
+            return segments;
+        const askEvent = events[askIndex];
+        const askStartTime = parseTime(askEvent.startTime) <= parseTime(askEvent.endTime)
+            ? askEvent.startTime
+            : askEvent.endTime;
+        const askEndTime = parseTime(askEvent.startTime) <= parseTime(askEvent.endTime)
+            ? askEvent.endTime
+            : askEvent.startTime;
+        if (parseTime(askEndTime) <= parseTime(askStartTime))
+            return segments;
+        segments[segments.length - 1] = {
+            start: segments[segments.length - 1].start,
+            end: askStartTime
+        };
+        segments.push({
+            start: askEndTime,
+            end: taskItem.endTime
+        });
+        return segments;
+    };
+    const walkEvents = (events) => {
+        for (let index = 0; index < events.length; index += 1) {
+            const event = events[index];
+            const { type, startTime, endTime } = event;
+            switch (type) {
+                case 'tool__StartTasks': {
+                    const { tasks = {} } = event;
+                    const startTasksSectionId = nextSectionId('section');
+                    const startTasksSectionLabel = nextBlankSectionLabel();
+                    for (const [taskName, task] of Object.entries(tasks)) {
+                        const segments = collectTaskSegments(task);
+                        segments.forEach((segment, segmentIndex) => {
+                            const itemId = nextId('task');
+                            const label = segments.length > 1
+                                ? `${taskName} - ${segmentIndex}`
+                                : taskName;
+                            const interaction = {
+                                id: itemId,
+                                label: taskName,
+                                payload: {
+                                    kind: 'task',
+                                    name: taskName,
+                                    task
+                                }
+                            };
+                            items.push({
+                                id: itemId,
+                                label,
+                                start: normalizeTime(segment.start),
+                                end: normalizeTime(segment.end),
+                                sectionId: startTasksSectionId,
+                                sectionLabel: startTasksSectionLabel,
+                                type: 'task',
+                                interaction
+                            });
+                            addInteraction(interaction);
+                        });
+                        const { events: taskEvents = [] } = task;
+                        if (taskEvents.length > 0) {
+                            walkEvents(taskEvents);
+                        }
+                    }
+                    break;
+                }
+                case 'tool__ResumeTask': {
+                    break;
+                }
+                case 'user__Prompt': {
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+    };
+    const mainItemId = nextId('main');
+    const mainSectionId = nextSectionId('section');
+    items.push({
+        id: mainItemId,
+        label: labels.ganttMainSection,
+        start: normalizeTime(task.startTime),
+        end: normalizeTime(task.endTime),
+        sectionId: mainSectionId,
+        sectionLabel: labels.ganttMainSection,
+        type: 'task'
+    });
+    walkEvents(task.events ?? []);
+    return {
+        items,
+        interactions
+    };
+}
+function buildGanttLines(items) {
+    const lines = [
+        'gantt',
+        'dateFormat HH:mm:ss',
+        'axisFormat %H:%M:%S'
+    ];
+    const sections = new Map();
+    for (const item of items) {
+        if (!sections.has(item.sectionId)) {
+            sections.set(item.sectionId, { label: item.sectionLabel, items: [] });
+        }
+        sections.get(item.sectionId)?.items.push(item);
+    }
+    for (const section of sections.values()) {
+        lines.push(section.label ? `section ${section.label}` : 'section');
+        for (const item of section.items) {
+            if (item.end) {
+                lines.push(`${item.label} :${item.id}, ${item.start}, ${item.end}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+export function buildGantt(task, labels) {
+    const { items, interactions } = collectGanttItems(task, labels);
+    return {
+        code: buildGanttLines(items),
+        interactions
+    };
+}

package/dist/apps/client/src/components/chat/session-timeline-panel/git-graph.d.ts

@@ -0,0 +1,20 @@
+import type { Task, TimelineDiagram } from './types';
+interface MermaidLabels {
+    mainStart: string;
+    mainEnd: string;
+    startTasks: string;
+    allTasksDone: string;
+    askUserQuestion: string;
+    edit: string;
+    resumeTask: string;
+    userPrompt: string;
+    userAnswer: string;
+    receiveReply: string;
+    taskStart: string;
+    taskEnd: string;
+    ganttTitle: string;
+    ganttMainSection: string;
+    ganttTasksSection: string;
+}
+export declare function buildGitGraph(task: Task, labels: MermaidLabels): TimelineDiagram;
+export {};

package/dist/apps/client/src/components/chat/session-timeline-panel/git-graph.js

@@ -0,0 +1,370 @@
+import { parseTime, sanitizeId } from './utils';
+function formatTag(action) {
+    if (!action)
+        return undefined;
+    return action.replace(/"/g, "'");
+}
+function createCommitIdAllocator(usedCommitIds) {
+    const normalizeCommitId = (value) => value.replace(/\s+/g, '_');
+    const allocateCommitId = (baseId) => {
+        let finalId = baseId;
+        let bump = 1;
+        while (usedCommitIds.has(finalId)) {
+            finalId = `${baseId}_${bump}`;
+            bump += 1;
+        }
+        usedCommitIds.add(finalId);
+        return finalId;
+    };
+    return {
+        normalizeCommitId,
+        allocateCommitId
+    };
+}
+function getEventTitle(labels, type) {
+    switch (type) {
+        case 'tool__StartTasks':
+            return labels.startTasks;
+        case 'tool__AskUserQuestion':
+            return labels.askUserQuestion;
+        case 'tool__Edit':
+            return labels.edit;
+        case 'tool__ResumeTask':
+            return labels.resumeTask;
+        case 'user__Prompt':
+            return labels.userPrompt;
+        default:
+            return type;
+    }
+}
+function getOpBranchName(op) {
+    switch (op.kind) {
+        case 'merge':
+            return op.target;
+        case 'branch':
+            return op.name;
+        default:
+            return op.branch;
+    }
+}
+function sortTimelineOps(ops) {
+    return [...ops].sort((a, b) => {
+        const timeDiff = parseTime(a.time) - parseTime(b.time);
+        if (timeDiff !== 0)
+            return timeDiff;
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        const branchA = getOpBranchName(a);
+        const branchB = getOpBranchName(b);
+        if (branchA !== branchB)
+            return branchA.localeCompare(branchB);
+        return a.seq - b.seq;
+    });
+}
+function createMermaidRuntime(labels) {
+    const lines = ['gitGraph TB:'];
+    const createdBranches = new Set();
+    const usedCommitIds = new Set();
+    const { normalizeCommitId, allocateCommitId } = createCommitIdAllocator(usedCommitIds);
+    const resumeCommitIds = new Map();
+    const latestCommitIds = new Map();
+    const commitBranchById = new Map();
+    const parentByBranch = new Map();
+    let globalLatestCommit;
+    let curBranch;
+    let opSeq = 0;
+    const ops = [];
+    const interactions = [];
+    const commit = (commitId, action) => {
+        const safeAction = formatTag(action);
+        if (safeAction) {
+            lines.push(`commit id:"${commitId}" tag:"${safeAction}"`);
+        }
+        else {
+            lines.push(`commit id:"${commitId}"`);
+        }
+        return commitId;
+    };
+    const updateGlobalLatestCommit = (commitId, branchName, time, seq) => {
+        if (!globalLatestCommit) {
+            globalLatestCommit = {
+                id: commitId,
+                branch: branchName,
+                time,
+                seq
+            };
+            return;
+        }
+        const timeDiff = parseTime(time) - parseTime(globalLatestCommit.time);
+        if (timeDiff > 0 || (timeDiff === 0 && seq > globalLatestCommit.seq)) {
+            globalLatestCommit = {
+                id: commitId,
+                branch: branchName,
+                time,
+                seq
+            };
+        }
+    };
+    const findLatestCommitIdByBranch = (branchName) => {
+        let cursor = branchName;
+        while (cursor) {
+            const commitId = latestCommitIds.get(cursor);
+            if (commitId) {
+                return {
+                    id: commitId,
+                    branch: commitBranchById.get(commitId) ?? cursor
+                };
+            }
+            const parent = parentByBranch.get(cursor);
+            if (!parent || parent === cursor)
+                break;
+            cursor = parent;
+        }
+        return undefined;
+    };
+    const findLatestCommitId = (branchName) => {
+        if (branchName)
+            return findLatestCommitIdByBranch(branchName);
+        if (!globalLatestCommit)
+            return undefined;
+        return {
+            id: globalLatestCommit.id,
+            branch: globalLatestCommit.branch
+        };
+    };
+    const addCommit = (timeId, action, options, payload) => {
+        const baseId = normalizeCommitId(timeId);
+        const commitId = allocateCommitId(baseId);
+        if (options?.branchName && typeof options.priority === 'number') {
+            ops.push({
+                kind: 'commit',
+                time: timeId,
+                branch: options.branchName,
+                commitId,
+                action,
+                priority: options.priority,
+                seq: opSeq++
+            });
+            latestCommitIds.set(options.branchName, commitId);
+            commitBranchById.set(commitId, options.branchName);
+            updateGlobalLatestCommit(commitId, options.branchName, timeId, opSeq - 1);
+            if (payload) {
+                interactions.push({
+                    id: commitId,
+                    label: action ?? commitId,
+                    payload
+                });
+            }
+            return commitId;
+        }
+        if (payload) {
+            interactions.push({
+                id: commitId,
+                label: action ?? commitId,
+                payload
+            });
+        }
+        return commit(commitId, action);
+    };
+    const branch = (name) => {
+        if (createdBranches.has(name))
+            return;
+        createdBranches.add(name);
+        curBranch = name;
+        lines.push(`branch ${name}`);
+    };
+    const checkout = (name) => {
+        curBranch = name;
+        lines.push(`checkout ${name}`);
+    };
+    const merge = (name, id, action, options) => {
+        const items = [];
+        if (id) {
+            items.push(`id:"${id}"`);
+        }
+        if (action) {
+            items.push(`tag:"${action}"`);
+        }
+        lines.push(`merge ${name} ${items.join(' ')}`);
+        if (id && options?.branchName && options.time && typeof options.seq === 'number') {
+            latestCommitIds.set(options.branchName, id);
+            commitBranchById.set(id, options.branchName);
+            updateGlobalLatestCommit(id, options.branchName, options.time, options.seq);
+        }
+    };
+    const addBranch = (time, baseBranch, name, priority) => {
+        ops.push({
+            kind: 'branch',
+            time,
+            baseBranch,
+            name,
+            priority,
+            seq: opSeq++
+        });
+    };
+    const addMerge = (time, target, source, action, priority, payload) => {
+        const baseId = normalizeCommitId(time);
+        const mergeId = allocateCommitId(baseId);
+        ops.push({
+            kind: 'merge',
+            time,
+            target,
+            source,
+            action,
+            mergeId,
+            priority,
+            seq: opSeq++
+        });
+        if (payload) {
+            interactions.push({
+                id: mergeId,
+                label: action,
+                payload
+            });
+        }
+        return mergeId;
+    };
+    const mainBranch = 'main';
+    const ensureBranch = (name) => {
+        if (name === mainBranch)
+            return;
+        branch(name);
+    };
+    return {
+        get curBranch() {
+            return curBranch;
+        },
+        labels,
+        lines,
+        ops,
+        interactions,
+        commit,
+        branch,
+        checkout,
+        merge,
+        addCommit,
+        addBranch,
+        addMerge,
+        ensureBranch,
+        normalizeCommitId,
+        allocateCommitId,
+        findLatestCommitId,
+        resumeCommitIds,
+        parentByBranch
+    };
+}
+function walkTimelineEvents(events, activeBranch, parentBranch, runtime) {
+    const { labels, addCommit, addBranch, addMerge, parentByBranch, resumeCommitIds } = runtime;
+    for (const event of events) {
+        const { type, startTime, endTime } = event;
+        switch (type) {
+            case 'tool__StartTasks': {
+                addCommit(startTime, labels.taskStart, { branchName: activeBranch, priority: 10 }, {
+                    kind: 'event',
+                    event
+                });
+                const { tasks = {} } = event;
+                for (const [taskName, task] of Object.entries(tasks)) {
+                    const taskBranch = sanitizeId(taskName);
+                    parentByBranch.set(taskBranch, activeBranch);
+                    addBranch(startTime, activeBranch, taskBranch, 15);
+                    addCommit(task.startTime, labels.taskStart, { branchName: taskBranch, priority: 16 }, {
+                        kind: 'task',
+                        name: taskName,
+                        task
+                    });
+                    const { events: taskEvents = [] } = task;
+                    if (taskEvents.length > 0) {
+                        walkTimelineEvents(taskEvents, taskBranch, activeBranch, runtime);
+                    }
+                    addCommit(task.endTime, labels.taskEnd, { branchName: taskBranch, priority: 60 });
+                }
+                addCommit(endTime, labels.allTasksDone, { branchName: activeBranch, priority: 70 });
+                break;
+            }
+            case 'tool__AskUserQuestion':
+                addCommit(startTime, labels.askUserQuestion, { branchName: activeBranch, priority: 20 }, {
+                    kind: 'event',
+                    event
+                });
+                addMerge(endTime, parentBranch, activeBranch, labels.userAnswer, 80, {
+                    kind: 'event',
+                    event
+                });
+                break;
+            case 'tool__Edit':
+                addCommit(startTime, getEventTitle(labels, type), { branchName: activeBranch, priority: 30 }, {
+                    kind: 'event',
+                    event
+                });
+                break;
+            case 'tool__ResumeTask': {
+                const commitId = addCommit(startTime, getEventTitle(labels, type), {
+                    branchName: activeBranch,
+                    priority: 40
+                }, {
+                    kind: 'event',
+                    event
+                });
+                resumeCommitIds.set(activeBranch, commitId);
+                break;
+            }
+            case 'user__Prompt':
+                addMerge(startTime, activeBranch, '<prev_branch>', getEventTitle(labels, type), 50, {
+                    kind: 'event',
+                    event
+                });
+                break;
+            default:
+                addCommit(endTime, getEventTitle(labels, type), { branchName: activeBranch, priority: 55 }, {
+                    kind: 'event',
+                    event
+                });
+                break;
+        }
+    }
+}
+function applyTimelineOps(runtime) {
+    const sortedOps = sortTimelineOps(runtime.ops);
+    for (const op of sortedOps) {
+        switch (op.kind) {
+            case 'commit':
+                runtime.ensureBranch(op.branch);
+                runtime.checkout(op.branch);
+                runtime.commit(op.commitId, op.action);
+                break;
+            case 'branch':
+                runtime.checkout(op.baseBranch);
+                runtime.ensureBranch(op.name);
+                break;
+            case 'merge': {
+                if (op.source === '<prev_branch>') {
+                    op.source = runtime.curBranch;
+                }
+                runtime.ensureBranch(op.target);
+                runtime.ensureBranch(op.source);
+                runtime.checkout(op.target);
+                runtime.merge(op.source, op.mergeId, op.action, {
+                    branchName: op.target,
+                    time: op.time,
+                    seq: op.seq
+                });
+                break;
+            }
+        }
+    }
+}
+export function buildGitGraph(task, labels) {
+    const runtime = createMermaidRuntime(labels);
+    const mainBranch = 'main';
+    runtime.checkout(mainBranch);
+    runtime.addCommit(task.startTime, labels.mainStart);
+    walkTimelineEvents(task.events ?? [], mainBranch, mainBranch, runtime);
+    applyTimelineOps(runtime);
+    runtime.checkout(mainBranch);
+    runtime.addCommit(task.endTime, labels.mainEnd);
+    return {
+        code: runtime.lines.join('\n'),
+        interactions: runtime.interactions
+    };
+}

package/dist/apps/client/src/components/chat/session-timeline-panel/index.d.ts

@@ -0,0 +1,10 @@
+import './index.scss';
+import React from 'react';
+import type { Task } from './types';
+export interface SessionTimelinePanelProps {
+    task: Task;
+    viewMode: 'git' | 'gantt';
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function SessionTimelinePanel(props: SessionTimelinePanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/apps/client/src/components/chat/session-timeline-panel/index.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import './index.scss';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { buildGantt, buildGitGraph } from './mermaid';
+export function SessionTimelinePanel(props) {
+    const { task, viewMode, className, style } = props;
+    const containerRef = React.useRef(null);
+    const { t } = useTranslation();
+    const labels = React.useMemo(() => ({
+        mainStart: t('chat.timeline.mainStart'),
+        mainEnd: t('chat.timeline.mainEnd'),
+        startTasks: t('chat.timeline.startTasks'),
+        allTasksDone: t('chat.timeline.allTasksDone'),
+        askUserQuestion: t('chat.timeline.askUserQuestion'),
+        edit: t('chat.timeline.edit'),
+        resumeTask: t('chat.timeline.resumeTask'),
+        userPrompt: t('chat.timeline.userPrompt'),
+        userAnswer: t('chat.timeline.userAnswer'),
+        receiveReply: t('chat.timeline.receiveReply'),
+        taskStart: t('chat.timeline.taskStart'),
+        taskEnd: t('chat.timeline.taskEnd'),
+        ganttTitle: t('chat.timeline.ganttTitle'),
+        ganttMainSection: t('chat.timeline.ganttMainSection'),
+        ganttTasksSection: t('chat.timeline.ganttTasksSection')
+    }), [t]);
+    const diagram = React.useMemo(() => {
+        if (viewMode === 'gantt') {
+            return buildGantt(task, labels);
+        }
+        return buildGitGraph(task, labels);
+    }, [labels, task, viewMode]);
+    const diagramId = React.useId();
+    const safeDiagramId = React.useMemo(() => diagramId.replace(/\W/g, '_'), [diagramId]);
+    const interactionsRef = React.useRef(new Map());
+    const mermaidCode = React.useMemo(() => diagram.code, [diagram.code]);
+    React.useEffect(() => {
+        let cancelled = false;
+        const render = async () => {
+            const mermaidModule = await import('mermaid');
+            const mermaid = mermaidModule.default;
+            const fontFamily = getComputedStyle(document.body).fontFamily;
+            mermaid.initialize({
+                startOnLoad: false,
+                securityLevel: 'loose',
+                themeVariables: {
+                    fontFamily
+                },
+                gitGraph: {},
+                gantt: {
+                    topAxis: true,
+                    displayMode: 'compact',
+                    gridLineStartPadding: 0,
+                    leftPadding: 16,
+                    rightPadding: 16
+                }
+            });
+            if (cancelled)
+                return;
+            const container = containerRef.current;
+            if (!container)
+                return;
+            const { svg, bindFunctions } = await mermaid.render(safeDiagramId, mermaidCode);
+            if (cancelled)
+                return;
+            container.innerHTML = svg;
+            const svgElement = container.querySelector('svg');
+            if (svgElement) {
+                svgElement.classList.add('session-timeline-mermaid__svg');
+                for (const interaction of diagram.interactions) {
+                    const target = svgElement.querySelector(`#${CSS.escape(interaction.id)}`);
+                    if (target) {
+                        target.classList.add('session-timeline-mermaid__interactive');
+                        target.addEventListener('click', () => {
+                            const item = interactionsRef.current.get(interaction.id);
+                            if (!item)
+                                return;
+                            console.warn(item.payload);
+                        });
+                    }
+                }
+            }
+            if (typeof bindFunctions === 'function') {
+                bindFunctions(container);
+            }
+        };
+        render();
+        return () => {
+            cancelled = true;
+        };
+    }, [diagram.interactions, mermaidCode, safeDiagramId]);
+    React.useEffect(() => {
+        interactionsRef.current = new Map(diagram.interactions.map((interaction) => [
+            interaction.id,
+            { label: interaction.label, payload: interaction.payload }
+        ]));
+    }, [diagram.interactions]);
+    return (_jsx("div", { ref: containerRef, className: `session-timeline-panel session-timeline-panel--${viewMode}${className ? ` ${className}` : ''}`, style: style }));
+}

package/dist/apps/client/src/components/chat/session-timeline-panel/mermaid.d.ts

@@ -0,0 +1,4 @@
+export * from './gantt';
+export * from './git-graph';
+export * from './types';
+export * from './utils';

package/dist/apps/client/src/components/chat/session-timeline-panel/mermaid.js

@@ -0,0 +1,4 @@
+export * from './gantt';
+export * from './git-graph';
+export * from './types';
+export * from './utils';