201 lines
6.3 KiB
TypeScript
201 lines
6.3 KiB
TypeScript
/**
|
|
* Local-only draft storage for /page/roundtable/planning.
|
|
*
|
|
* One draft = one full roundtable session (Step 1 intent + Step 2 multi-agent
|
|
* roundtable). Persisted in `localStorage` so refresh / browser-restart keeps
|
|
* it; cross-device sync is out of scope (would need a backend). The Step 2
|
|
* back-end LangGraph threads are reused on load, so list/preview/download of
|
|
* artifacts in Step 3 continue to work as long as the user hasn't deleted the
|
|
* threads server-side.
|
|
*/
|
|
|
|
import type { IntentSummary } from "@/roundtable-planning/api/intent";
|
|
import type { ThreadIdMap } from "@/roundtable-planning/api/multi-agent";
|
|
|
|
const STORAGE_KEY = "roundtable-planning:drafts:v1";
|
|
|
|
/**
|
|
* Snapshot of every piece of UI state needed to resume a session. We capture
|
|
* shapes loosely (`unknown[]`) for the chat / role lists because their inline
|
|
* types in the page component are wide and would force a refactor we don't
|
|
* want as part of the persistence feature.
|
|
*/
|
|
export interface DraftStep1Snapshot {
|
|
intentThreadId: string | null;
|
|
intentReady: IntentSummary | null;
|
|
interactiveMessages: unknown[];
|
|
timelineEntries: unknown[];
|
|
}
|
|
|
|
export interface DraftStep2Snapshot {
|
|
threadIds: ThreadIdMap | null;
|
|
coordinatorName: string | null;
|
|
step2RoundtableDialogues: unknown[];
|
|
lastLeaderContent: string;
|
|
hasConsensus: boolean;
|
|
consensusPercentage: number;
|
|
budgetLimit: number;
|
|
/**
|
|
* Per-seat stub AI messages used by the sandbox `write-file:` virtual URL
|
|
* loader. Older drafts won't have this — callers should default to `{}`.
|
|
*/
|
|
seatStubMessages?: Record<string, unknown[]>;
|
|
}
|
|
|
|
export interface DraftRecord {
|
|
id: string;
|
|
/** Auto-derived task summary (objective → first user message → timestamp). */
|
|
name: string;
|
|
createdAt: string;
|
|
updatedAt: string;
|
|
/** Furthest step the user had reached when this snapshot was taken. */
|
|
furthestStep: 1 | 2 | 3;
|
|
step1: DraftStep1Snapshot;
|
|
step2: DraftStep2Snapshot;
|
|
}
|
|
|
|
function isBrowser(): boolean {
|
|
return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
|
|
}
|
|
|
|
function readAll(): DraftRecord[] {
|
|
if (!isBrowser()) return [];
|
|
try {
|
|
const raw = window.localStorage.getItem(STORAGE_KEY);
|
|
if (!raw) return [];
|
|
const parsed = JSON.parse(raw);
|
|
if (!Array.isArray(parsed)) return [];
|
|
return parsed as DraftRecord[];
|
|
} catch (err) {
|
|
console.warn("[drafts] failed to parse localStorage payload:", err);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
function writeAll(records: DraftRecord[]): void {
|
|
if (!isBrowser()) return;
|
|
try {
|
|
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(records));
|
|
} catch (err) {
|
|
// Quota errors are the realistic failure mode — surface but don't throw,
|
|
// since the user can keep working with their in-memory state.
|
|
console.warn("[drafts] failed to write localStorage payload:", err);
|
|
}
|
|
}
|
|
|
|
function newId(): string {
|
|
if (isBrowser() && typeof window.crypto !== "undefined" && typeof window.crypto.randomUUID === "function") {
|
|
return window.crypto.randomUUID();
|
|
}
|
|
return `draft-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
|
|
}
|
|
|
|
/** List drafts newest first. */
|
|
export function listDrafts(): DraftRecord[] {
|
|
return readAll()
|
|
.slice()
|
|
.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
|
|
}
|
|
|
|
export function getDraft(id: string): DraftRecord | null {
|
|
return readAll().find((d) => d.id === id) ?? null;
|
|
}
|
|
|
|
/**
|
|
* Create-or-update a draft. If `id` is given and exists, that record is
|
|
* overwritten (updatedAt refreshed). Otherwise a new record is inserted.
|
|
* Returns the (re-)saved record so callers can read back the new id.
|
|
*/
|
|
export function upsertDraft(
|
|
payload: Omit<DraftRecord, "createdAt" | "updatedAt" | "id"> & { id?: string },
|
|
): DraftRecord {
|
|
const records = readAll();
|
|
const now = new Date().toISOString();
|
|
|
|
if (payload.id) {
|
|
const idx = records.findIndex((d) => d.id === payload.id);
|
|
if (idx >= 0) {
|
|
const existing = records[idx];
|
|
const updated: DraftRecord = {
|
|
...existing,
|
|
name: payload.name,
|
|
furthestStep: payload.furthestStep,
|
|
step1: payload.step1,
|
|
step2: payload.step2,
|
|
updatedAt: now,
|
|
};
|
|
records[idx] = updated;
|
|
writeAll(records);
|
|
return updated;
|
|
}
|
|
}
|
|
|
|
const created: DraftRecord = {
|
|
id: payload.id ?? newId(),
|
|
name: payload.name,
|
|
furthestStep: payload.furthestStep,
|
|
step1: payload.step1,
|
|
step2: payload.step2,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
};
|
|
records.push(created);
|
|
writeAll(records);
|
|
return created;
|
|
}
|
|
|
|
export function deleteDraft(id: string): void {
|
|
const records = readAll();
|
|
const next = records.filter((d) => d.id !== id);
|
|
if (next.length !== records.length) writeAll(next);
|
|
}
|
|
|
|
/**
|
|
* Rename a draft. No-op when `id` isn't found or `name` is empty. Returns the
|
|
* updated record so callers can refresh local UI state.
|
|
*/
|
|
export function renameDraft(id: string, name: string): DraftRecord | null {
|
|
const trimmed = name.trim();
|
|
if (!trimmed) return null;
|
|
const records = readAll();
|
|
const idx = records.findIndex((d) => d.id === id);
|
|
if (idx < 0) return null;
|
|
const updated: DraftRecord = {
|
|
...records[idx],
|
|
name: trimmed,
|
|
updatedAt: new Date().toISOString(),
|
|
};
|
|
records[idx] = updated;
|
|
writeAll(records);
|
|
return updated;
|
|
}
|
|
|
|
/**
|
|
* Derive a short task-summary name from whatever the user has supplied so far.
|
|
* Preference order: intent agent's structured objective → first user message
|
|
* in Step 1 → ISO timestamp fallback. The result is trimmed to ~40 chars so
|
|
* the dropdown rows stay scannable.
|
|
*/
|
|
export function deriveDraftName(args: {
|
|
intentReady?: IntentSummary | null;
|
|
interactiveMessages?: unknown[];
|
|
}): string {
|
|
const MAX = 40;
|
|
const truncate = (s: string) => (s.length > MAX ? s.slice(0, MAX) + "…" : s);
|
|
|
|
const objective = args.intentReady?.objective?.trim();
|
|
if (objective) return truncate(objective);
|
|
|
|
if (Array.isArray(args.interactiveMessages)) {
|
|
for (const m of args.interactiveMessages) {
|
|
if (!m || typeof m !== "object") continue;
|
|
const obj = m as Record<string, unknown>;
|
|
if (obj.sender === "user" && typeof obj.content === "string" && obj.content.trim()) {
|
|
return truncate(obj.content.trim());
|
|
}
|
|
}
|
|
}
|
|
|
|
return `未命名草稿 ${new Date().toLocaleString("zh-CN", { hour12: false })}`;
|
|
}
|