@openspecui/core 5.0.0 → 6.0.0-beta.1

package/dist/common-D8YUK9dA.mjs

@@ -0,0 +1,57 @@
+import { z } from "zod";
+
+//#region src/cli-contracts/common.ts
+/**
+* Orthogonal intents (created 2026-07-15 Asia/Shanghai):
+* 1. Model OpenSpec CLI diagnostics without reinterpreting their meaning.
+* 2. Preserve root selection provenance exactly as emitted by the CLI.
+* 3. Preserve direct Reference indexes and their upstream health evidence.
+*
+* Original request (2026-07-15): "CLI JSON、stderr、诊断、resolved paths、root provenance、exit status 必须完整保留。"
+*/
+/** Upstream diagnostic emitted in a CLI JSON status array. */
+const CliDiagnosticSchema = z.object({
+	severity: z.enum([
+		"error",
+		"warning",
+		"info"
+	]),
+	code: z.string(),
+	message: z.string(),
+	target: z.string().optional(),
+	fix: z.string().optional()
+}).passthrough();
+/** Upstream provenance for the CLI-selected planning root. */
+const CliRootSourceSchema = z.enum([
+	"store",
+	"declared",
+	"nearest",
+	"implicit"
+]);
+/** CLI-selected planning root with upstream selection provenance. */
+const CliRootSchema = z.object({
+	path: z.string(),
+	source: CliRootSourceSchema,
+	store_id: z.string().optional()
+}).passthrough();
+/** Lightweight Spec fact exposed by a direct Reference index. */
+const CliReferenceSpecSchema = z.object({
+	id: z.string(),
+	summary: z.string()
+}).passthrough();
+/** Health-only direct Reference entry emitted by OpenSpec Doctor. */
+const CliDoctorReferenceEntrySchema = z.object({
+	store_id: z.string(),
+	root: z.string().optional(),
+	status: z.array(CliDiagnosticSchema)
+}).passthrough();
+/** Spec-bearing direct Reference index emitted by workflow Instructions. */
+const CliReferenceIndexEntrySchema = CliDoctorReferenceEntrySchema.extend({
+	specs: z.array(CliReferenceSpecSchema).optional(),
+	fetch: z.string().optional()
+}).passthrough();
+/** JSON failure payload whose truth is carried entirely by upstream diagnostics. */
+const CliDiagnosticFailureSchema = z.object({ status: z.array(CliDiagnosticSchema).min(1) }).passthrough();
+
+//#endregion
+export { CliRootSchema as a, CliReferenceIndexEntrySchema as i, CliDiagnosticSchema as n, CliRootSourceSchema as o, CliDoctorReferenceEntrySchema as r, CliDiagnosticFailureSchema as t };

package/dist/dashboard-display.d.mts

@@ -1,5 +1,24 @@
 //#region src/dashboard-display.d.ts
+/**
+ * Orthogonal intents (updated 2026-07-28 Asia/Shanghai):
+ * 1. Select bounded Dashboard rows with deterministic ordering.
+ * 2. Resolve archive dates identically across Server and browser/static consumers.
+ * 3. Apply the objective bounded archive-range policy without owning UI state.
+ *
+ * Original request (2026-07-28): replace Dashboard Workflow Progress with ReadonlyKanban.
+ */
 declare const DASHBOARD_RECENT_LIST_LIMIT = 10;
+type DashboardArchiveRange = '7d' | '30d' | '90d' | 'all';
+interface DashboardArchiveTimeSource {
+  id: string;
+  updatedAt: number;
+}
+/** Parse a valid UTC calendar date from an archive id prefix. */
+declare function parseDatedArchiveIdTimestamp(id: string): number | null;
+/** Resolve the archive timestamp from its dated id, then its physical update time. */
+declare function resolveArchiveTimestamp(archive: DashboardArchiveTimeSource): number;
+/** Test whether an archive belongs to a user-selected trailing range. */
+declare function isArchiveInRange(archive: DashboardArchiveTimeSource, range: DashboardArchiveRange, now?: number): boolean;
 interface DashboardRecentListItem {
   id: string;
   updatedAt: number;
@@ -7,5 +26,7 @@ interface DashboardRecentListItem {
 declare function compareDashboardItemsByUpdatedAt<T extends DashboardRecentListItem>(left: T, right: T): number;
 declare function sortDashboardItemsByUpdatedAt<T extends DashboardRecentListItem>(items: readonly T[]): T[];
 declare function selectRecentDashboardItems<T extends DashboardRecentListItem>(items: readonly T[], limit?: number): T[];
+/** Select recent archives by objective archive time rather than incidental directory mtime. */
+declare function selectRecentDashboardArchives<T extends DashboardArchiveTimeSource>(items: readonly T[], limit?: number): T[];
 //#endregion
-export { DASHBOARD_RECENT_LIST_LIMIT, DashboardRecentListItem, compareDashboardItemsByUpdatedAt, selectRecentDashboardItems, sortDashboardItemsByUpdatedAt };
+export { DASHBOARD_RECENT_LIST_LIMIT, DashboardArchiveRange, DashboardArchiveTimeSource, DashboardRecentListItem, compareDashboardItemsByUpdatedAt, isArchiveInRange, parseDatedArchiveIdTimestamp, resolveArchiveTimestamp, selectRecentDashboardArchives, selectRecentDashboardItems, sortDashboardItemsByUpdatedAt };

package/dist/dashboard-display.mjs

@@ -1,5 +1,42 @@
 //#region src/dashboard-display.ts
+/**
+* Orthogonal intents (updated 2026-07-28 Asia/Shanghai):
+* 1. Select bounded Dashboard rows with deterministic ordering.
+* 2. Resolve archive dates identically across Server and browser/static consumers.
+* 3. Apply the objective bounded archive-range policy without owning UI state.
+*
+* Original request (2026-07-28): replace Dashboard Workflow Progress with ReadonlyKanban.
+*/
 const DASHBOARD_RECENT_LIST_LIMIT = 10;
+const ARCHIVE_RANGE_DAYS = {
+	"7d": 7,
+	"30d": 30,
+	"90d": 90,
+	all: null
+};
+const ARCHIVE_DATE_PREFIX = /^(\d{4})-(\d{2})-(\d{2})(?:-|$)/;
+/** Parse a valid UTC calendar date from an archive id prefix. */
+function parseDatedArchiveIdTimestamp(id) {
+	const match = ARCHIVE_DATE_PREFIX.exec(id);
+	if (!match) return null;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	const timestamp = Date.UTC(year, month - 1, day);
+	const parsed = new Date(timestamp);
+	if (!Number.isFinite(timestamp) || parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) return null;
+	return timestamp;
+}
+/** Resolve the archive timestamp from its dated id, then its physical update time. */
+function resolveArchiveTimestamp(archive) {
+	return parseDatedArchiveIdTimestamp(archive.id) ?? archive.updatedAt;
+}
+/** Test whether an archive belongs to a user-selected trailing range. */
+function isArchiveInRange(archive, range, now = Date.now()) {
+	const days = ARCHIVE_RANGE_DAYS[range];
+	if (days === null) return true;
+	return resolveArchiveTimestamp(archive) >= now - days * 24 * 60 * 60 * 1e3;
+}
 function compareDashboardItemsByUpdatedAt(left, right) {
 	return right.updatedAt - left.updatedAt || left.id.localeCompare(right.id);
 }
@@ -9,6 +46,10 @@ function sortDashboardItemsByUpdatedAt(items) {
 function selectRecentDashboardItems(items, limit = DASHBOARD_RECENT_LIST_LIMIT) {
 	return sortDashboardItemsByUpdatedAt(items).slice(0, Math.max(0, Math.trunc(limit)));
 }
+/** Select recent archives by objective archive time rather than incidental directory mtime. */
+function selectRecentDashboardArchives(items, limit = DASHBOARD_RECENT_LIST_LIMIT) {
+	return [...items].sort((left, right) => resolveArchiveTimestamp(right) - resolveArchiveTimestamp(left) || left.id.localeCompare(right.id)).slice(0, Math.max(0, Math.trunc(limit)));
+}
 
 //#endregion
-export { DASHBOARD_RECENT_LIST_LIMIT, compareDashboardItemsByUpdatedAt, selectRecentDashboardItems, sortDashboardItemsByUpdatedAt };
+export { DASHBOARD_RECENT_LIST_LIMIT, compareDashboardItemsByUpdatedAt, isArchiveInRange, parseDatedArchiveIdTimestamp, resolveArchiveTimestamp, selectRecentDashboardArchives, selectRecentDashboardItems, sortDashboardItemsByUpdatedAt };

package/dist/dashboard-summary-transport-CYBuU4iT.mjs

@@ -0,0 +1,189 @@
+import { d as TrackedTaskProgressSchema } from "./schemas-BFroDdOC.mjs";
+import { s as CliProjectionStateNameSchema, u as createCliProjectionStateSchema } from "./cli-projection-vO3-FJg5.mjs";
+import { z } from "zod";
+
+//#region src/dashboard-types.ts
+/**
+* Orthogonal intents (updated 2026-07-23 Asia/Shanghai):
+* 1. Define Dashboard metrics, trends, planning projections, and Git snapshot contracts.
+* 2. Preserve backend-issued Code binding provenance on live Git snapshots.
+* 3. Split independently refreshable Summary and Trends facts from the aggregate Dashboard compatibility view.
+* 4. Carry objective Kanban phase counts and bounded archive summaries without workflow inference.
+*
+* Original request (2026-07-19): "代码已经提交，开始review。如果有问题，那么可更新change。"
+* Derived requirement (2026-07-19): Checkpoint 6.11 binds Dashboard snapshots to their Code token.
+* Original request (2026-07-23): "现在页面数据的加载数据非常慢（比如dashboard页面、changes页面都要等待非常久，页面刷新后，似乎后台没有缓存一样，也要加载很久。"
+* Original request (2026-07-28): replace Dashboard Workflow Progress with ReadonlyKanban.
+*/
+const DASHBOARD_METRIC_KEYS = [
+	"specifications",
+	"requirements",
+	"activeChanges",
+	"inProgressChanges",
+	"completedChanges",
+	"taskCompletionPercent"
+];
+const DashboardTrendPointSchema = z.object({
+	ts: z.number(),
+	value: z.number()
+});
+const DashboardTriColorTrendPointSchema = z.object({
+	ts: z.number(),
+	add: z.number(),
+	modify: z.number(),
+	delete: z.number()
+});
+const DashboardTrendRecordSchema = z.object({
+	specifications: z.array(DashboardTrendPointSchema),
+	requirements: z.array(DashboardTrendPointSchema),
+	activeChanges: z.array(DashboardTrendPointSchema),
+	inProgressChanges: z.array(DashboardTrendPointSchema),
+	completedChanges: z.array(DashboardTrendPointSchema),
+	taskCompletionPercent: z.array(DashboardTrendPointSchema)
+});
+const DashboardTriColorTrendRecordSchema = z.object({
+	specifications: z.array(DashboardTriColorTrendPointSchema),
+	requirements: z.array(DashboardTriColorTrendPointSchema),
+	activeChanges: z.array(DashboardTriColorTrendPointSchema),
+	inProgressChanges: z.array(DashboardTriColorTrendPointSchema),
+	completedChanges: z.array(DashboardTriColorTrendPointSchema),
+	taskCompletionPercent: z.array(DashboardTriColorTrendPointSchema)
+});
+const DashboardTrendKindsSchema = z.object({
+	specifications: z.enum(["monotonic", "bidirectional"]),
+	requirements: z.enum(["monotonic", "bidirectional"]),
+	activeChanges: z.enum(["monotonic", "bidirectional"]),
+	inProgressChanges: z.enum(["monotonic", "bidirectional"]),
+	completedChanges: z.enum(["monotonic", "bidirectional"]),
+	taskCompletionPercent: z.enum(["monotonic", "bidirectional"])
+});
+const DashboardCardAvailabilitySchema = z.discriminatedUnion("state", [z.object({ state: z.literal("ok") }), z.object({
+	state: z.literal("invalid"),
+	reason: z.enum(["semantic-uncomputable", "objective-history-unavailable"])
+})]);
+const DashboardCardAvailabilityRecordSchema = z.object({
+	specifications: DashboardCardAvailabilitySchema,
+	requirements: DashboardCardAvailabilitySchema,
+	activeChanges: DashboardCardAvailabilitySchema,
+	inProgressChanges: DashboardCardAvailabilitySchema,
+	completedChanges: DashboardCardAvailabilitySchema,
+	taskCompletionPercent: DashboardCardAvailabilitySchema
+});
+const DashboardSummarySchema = z.object({
+	specifications: z.number(),
+	requirements: z.number(),
+	activeChanges: z.number(),
+	inProgressChanges: z.number(),
+	completedChanges: z.number(),
+	archivedTasksCompleted: z.number(),
+	tasksTotal: z.number(),
+	tasksCompleted: z.number(),
+	taskCompletionPercent: z.number().nullable()
+});
+const DashboardGitDiffStatsSchema = z.object({
+	files: z.number(),
+	insertions: z.number(),
+	deletions: z.number()
+});
+const DashboardGitEntrySchema = z.discriminatedUnion("type", [z.object({
+	type: z.literal("commit"),
+	hash: z.string(),
+	title: z.string(),
+	committedAt: z.number(),
+	relatedChanges: z.array(z.string()),
+	diff: DashboardGitDiffStatsSchema
+}), z.object({
+	type: z.literal("uncommitted"),
+	title: z.string(),
+	updatedAt: z.number().nullable(),
+	relatedChanges: z.array(z.string()),
+	diff: DashboardGitDiffStatsSchema
+})]);
+const DashboardGitWorktreeSchema = z.object({
+	path: z.string(),
+	relativePath: z.string(),
+	pathAvailable: z.boolean(),
+	branchName: z.string(),
+	detached: z.boolean(),
+	isCurrent: z.boolean(),
+	ahead: z.number(),
+	behind: z.number(),
+	diff: DashboardGitDiffStatsSchema,
+	entries: z.array(DashboardGitEntrySchema)
+});
+const DashboardGitSnapshotSchema = z.object({
+	bindingToken: z.string().nullable(),
+	defaultBranch: z.string(),
+	worktrees: z.array(DashboardGitWorktreeSchema)
+});
+const DashboardSummaryProjectionSchema = z.object({
+	summary: DashboardSummarySchema,
+	specifications: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		requirements: z.number(),
+		updatedAt: z.number()
+	})),
+	activeChanges: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		trackedTaskProgress: TrackedTaskProgressSchema,
+		updatedAt: z.number()
+	})),
+	trackedTaskPhaseCounts: z.object({
+		"no-tasks": z.number(),
+		"in-progress": z.number(),
+		complete: z.number()
+	}),
+	recentArchives: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		trackedTaskProgress: TrackedTaskProgressSchema,
+		archivedAt: z.number(),
+		updatedAt: z.number()
+	}))
+});
+const DashboardTrendsProjectionSchema = z.object({
+	trends: DashboardTrendRecordSchema,
+	triColorTrends: DashboardTriColorTrendRecordSchema,
+	trendKinds: DashboardTrendKindsSchema,
+	cardAvailability: DashboardCardAvailabilityRecordSchema,
+	trendMeta: z.object({
+		pointLimit: z.number(),
+		lastUpdatedAt: z.number()
+	})
+});
+const DashboardOverviewSchema = DashboardSummaryProjectionSchema.merge(DashboardTrendsProjectionSchema).extend({ git: DashboardGitSnapshotSchema });
+
+//#endregion
+//#region src/dashboard-summary-transport.ts
+/**
+* Orthogonal intents (updated 2026-07-27 Asia/Shanghai):
+* 1. Define browser-safe opaque identity and wake-up contracts for Dashboard Summary v2.
+* 2. Define the full typed Summary projection state without exposing Planning-root filesystem provenance.
+* 3. Preserve retained versus current authority across fresh browser Documents.
+*
+* Original request (2026-07-23): "在已有content的时候，服务端推送变更，然后客户端收到推送通知，于是开始加载更新数据。"
+* Original request (2026-07-27): "Dashboard页面每次页面刷新的时候，它仍然要加载很多？"
+*/
+/** Opaque Server-issued identity; it is derived from, but never contains, a Planning-root path. */
+const DashboardSummaryIdentitySchema = z.string().regex(/^dashboard-summary-v2:[A-Za-z0-9_-]{43}$/);
+/** Reasons that can wake the migrated Summary adapter in this bounded v2 slice. */
+const DashboardSummaryInvalidationCauseSchema = z.enum([
+	"initial",
+	"server-push",
+	"root-rebind"
+]);
+/** Data-free subscription event. Replacement Summary data always arrives through the typed pull. */
+const DashboardSummaryInvalidationSchema = z.object({
+	identity: DashboardSummaryIdentitySchema,
+	workGeneration: z.number().int().nonnegative(),
+	snapshotGeneration: z.number().int().nonnegative().nullable(),
+	state: CliProjectionStateNameSchema,
+	cause: DashboardSummaryInvalidationCauseSchema
+}).strict();
+/** Full Summary Pull state correlated to the exact Server-owned work identity and generation. */
+const DashboardSummaryProjectionStateSchema = createCliProjectionStateSchema(DashboardSummaryProjectionSchema);
+
+//#endregion
+export { DASHBOARD_METRIC_KEYS as a, DashboardSummaryProjectionSchema as c, DashboardSummaryProjectionStateSchema as i, DashboardTrendsProjectionSchema as l, DashboardSummaryInvalidationCauseSchema as n, DashboardGitSnapshotSchema as o, DashboardSummaryInvalidationSchema as r, DashboardOverviewSchema as s, DashboardSummaryIdentitySchema as t };