selftune 0.2.23 → 0.2.25

package/packages/dashboard-core/src/gates/UpgradeCard.tsx

@@ -0,0 +1,89 @@
+import { ArrowUpRightIcon, CheckIcon, LockIcon } from "lucide-react";
+
+interface UpgradeAction {
+  href: string;
+  label: string;
+}
+
+interface UpgradeCardProps {
+  eyebrow: string;
+  title: string;
+  description: string;
+  highlights?: readonly string[];
+  primaryAction: UpgradeAction;
+  secondaryAction?: UpgradeAction;
+  note?: string;
+}
+
+export function UpgradeCard({
+  eyebrow,
+  title,
+  description,
+  highlights = [],
+  primaryAction,
+  secondaryAction,
+  note,
+}: UpgradeCardProps) {
+  return (
+    <section className="overflow-hidden rounded-[28px] border border-primary/15 bg-[radial-gradient(circle_at_top_left,rgba(79,242,255,0.18),transparent_32%),linear-gradient(180deg,rgba(8,16,27,0.98),rgba(7,12,22,0.96))] shadow-[0_24px_80px_rgba(0,0,0,0.35)]">
+      <div className="grid gap-10 p-8 lg:grid-cols-[minmax(0,1.1fr)_minmax(300px,0.9fr)] lg:p-10">
+        <div className="space-y-6">
+          <div className="inline-flex items-center gap-2 rounded-full border border-primary/20 bg-primary/10 px-3 py-1 text-[10px] font-semibold uppercase tracking-[0.22em] text-primary">
+            <LockIcon className="size-3" />
+            <span>{eyebrow}</span>
+          </div>
+          <div className="space-y-4">
+            <h1 className="max-w-2xl font-headline text-3xl font-semibold tracking-tight text-foreground sm:text-4xl">
+              {title}
+            </h1>
+            <p className="max-w-2xl text-base leading-7 text-slate-300">{description}</p>
+          </div>
+
+          <div className="flex flex-wrap gap-3">
+            <a
+              href={primaryAction.href}
+              target="_blank"
+              rel="noreferrer"
+              className="inline-flex items-center gap-2 rounded-full bg-primary px-5 py-2.5 text-sm font-medium text-primary-foreground transition hover:bg-primary/90"
+            >
+              <span>{primaryAction.label}</span>
+              <ArrowUpRightIcon className="size-4" />
+            </a>
+            {secondaryAction ? (
+              <a
+                href={secondaryAction.href}
+                target="_blank"
+                rel="noreferrer"
+                className="inline-flex items-center gap-2 rounded-full border border-border/60 bg-background/40 px-5 py-2.5 text-sm font-medium text-slate-200 transition hover:border-primary/30 hover:text-primary"
+              >
+                <span>{secondaryAction.label}</span>
+                <ArrowUpRightIcon className="size-4" />
+              </a>
+            ) : null}
+          </div>
+
+          {note ? <p className="text-sm text-slate-500">{note}</p> : null}
+        </div>
+
+        <div className="rounded-[24px] border border-white/8 bg-white/4 p-6 backdrop-blur-sm">
+          <div className="mb-4 text-[10px] font-semibold uppercase tracking-[0.22em] text-slate-500">
+            What unlocks
+          </div>
+          <div className="space-y-3">
+            {highlights.map((highlight) => (
+              <div
+                key={highlight}
+                className="flex items-start gap-3 rounded-2xl border border-white/6 bg-background/40 px-4 py-3"
+              >
+                <div className="mt-0.5 flex size-5 items-center justify-center rounded-full bg-primary/12 text-primary">
+                  <CheckIcon className="size-3.5" />
+                </div>
+                <p className="text-sm leading-6 text-slate-200">{highlight}</p>
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+    </section>
+  );
+}

package/packages/dashboard-core/src/gates/index.ts

@@ -0,0 +1,3 @@
+export { FeatureGate } from "./FeatureGate";
+export { LockedRoute } from "./LockedRoute";
+export { UpgradeCard } from "./UpgradeCard";

package/packages/dashboard-core/src/host/DashboardHostProvider.tsx

@@ -0,0 +1,62 @@
+import { createContext, useContext, useMemo, type ReactNode } from "react";
+
+import type { DashboardHostAdapter } from "./adapter";
+import type { Capabilities, DashboardFeatureKey } from "./capabilities";
+import { canUseFeature } from "./capabilities";
+
+export interface DashboardHostContextValue {
+  adapter: DashboardHostAdapter;
+  capabilities: Capabilities;
+}
+
+const DashboardHostContext = createContext<DashboardHostContextValue | null>(null);
+
+interface DashboardHostProviderProps {
+  adapter: DashboardHostAdapter;
+  capabilities: Capabilities;
+  children: ReactNode;
+}
+
+export function DashboardHostProvider({
+  adapter,
+  capabilities,
+  children,
+}: DashboardHostProviderProps) {
+  const value = useMemo(
+    () => ({
+      adapter,
+      capabilities,
+    }),
+    [adapter, capabilities],
+  );
+
+  return <DashboardHostContext.Provider value={value}>{children}</DashboardHostContext.Provider>;
+}
+
+export function useDashboardHost(): DashboardHostContextValue {
+  const context = useContext(DashboardHostContext);
+  if (!context) {
+    throw new Error("useDashboardHost must be used within a DashboardHostProvider");
+  }
+  return context;
+}
+
+export function useOptionalDashboardHost(): DashboardHostContextValue | null {
+  return useContext(DashboardHostContext);
+}
+
+export function useDashboardHostAdapter(): DashboardHostAdapter {
+  return useDashboardHost().adapter;
+}
+
+export function useOptionalDashboardHostAdapter(): DashboardHostAdapter | null {
+  return useOptionalDashboardHost()?.adapter ?? null;
+}
+
+export function useCapabilities(): Capabilities {
+  return useDashboardHost().capabilities;
+}
+
+export function useFeatureEnabled(feature: DashboardFeatureKey): boolean {
+  return canUseFeature(useCapabilities(), feature);
+}

package/packages/dashboard-core/src/host/adapter.ts

@@ -0,0 +1,47 @@
+import type {
+  AnalyticsModel,
+  OverviewModel,
+  RuntimeHealthModel,
+  SkillsModel,
+} from "../models/index";
+
+export interface DashboardUser {
+  id?: string;
+  name: string;
+  email?: string;
+  subtitle?: string;
+  image?: string | null;
+}
+
+export interface DashboardSessionState {
+  status: "loading" | "authenticated" | "anonymous";
+  user?: DashboardUser;
+}
+
+export interface DashboardHostLinks {
+  upgrade: string;
+  billing?: string;
+  docs?: string;
+  cloudDashboard?: string;
+}
+
+export interface DashboardHostActions {
+  signOut?(): Promise<void>;
+  openUpgrade(): void;
+  getOverviewWatchlist?(): Promise<string[]>;
+  updateOverviewWatchlist?(skills: string[]): Promise<string[]>;
+}
+
+export interface DashboardApiClient {
+  fetchOverview(): Promise<OverviewModel>;
+  fetchSkills(): Promise<SkillsModel>;
+  fetchAnalytics(): Promise<AnalyticsModel>;
+  fetchRuntimeHealth?(): Promise<RuntimeHealthModel>;
+}
+
+export interface DashboardHostAdapter {
+  useSession(): DashboardSessionState;
+  api: DashboardApiClient;
+  links: DashboardHostLinks;
+  actions: DashboardHostActions;
+}

package/packages/dashboard-core/src/host/capabilities.ts

@@ -0,0 +1,55 @@
+export const FEATURE_KEYS = [
+  "analytics",
+  "registry",
+  "signals",
+  "proposals",
+  "billing",
+  "teamAdmin",
+  "runtimeStatus",
+] as const;
+
+export const DISCOVERABLE_FEATURE_KEYS = ["registry", "signals", "proposals", "billing"] as const;
+
+export type DashboardHostKind = "local" | "cloud";
+export type DashboardPlan = "oss" | "pro" | "team";
+export type DashboardFeatureKey = (typeof FEATURE_KEYS)[number];
+export type DashboardDiscoverableFeatureKey = (typeof DISCOVERABLE_FEATURE_KEYS)[number];
+
+export type DashboardFeatureFlags = Record<DashboardFeatureKey, boolean>;
+export type DashboardDiscoverableFlags = Record<DashboardDiscoverableFeatureKey, boolean>;
+
+export interface Capabilities {
+  host: DashboardHostKind;
+  plan: DashboardPlan;
+  features: DashboardFeatureFlags;
+  discoverable: DashboardDiscoverableFlags;
+}
+
+export function canUseFeature(capabilities: Capabilities, feature: DashboardFeatureKey): boolean {
+  return capabilities.features[feature];
+}
+
+export function canDiscoverFeature(
+  capabilities: Capabilities,
+  feature: DashboardDiscoverableFeatureKey,
+): boolean {
+  return capabilities.discoverable[feature] || capabilities.features[feature];
+}
+
+export function withCapabilityOverrides(
+  base: Capabilities,
+  overrides: Partial<Capabilities>,
+): Capabilities {
+  return {
+    host: overrides.host ?? base.host,
+    plan: overrides.plan ?? base.plan,
+    features: {
+      ...base.features,
+      ...overrides.features,
+    },
+    discoverable: {
+      ...base.discoverable,
+      ...overrides.discoverable,
+    },
+  };
+}

package/packages/dashboard-core/src/host/index.ts

@@ -0,0 +1,3 @@
+export * from "./adapter";
+export * from "./capabilities";
+export * from "./DashboardHostProvider";

package/packages/dashboard-core/src/models/analytics.ts

@@ -0,0 +1,39 @@
+export interface PassRateTrendPointModel {
+  date: string;
+  passRate: number | null;
+  checkVolume: number;
+}
+
+export interface SkillRankingModel {
+  skillName: string;
+  passRate: number;
+  totalChecks: number;
+  rank?: number;
+}
+
+export interface DailyActivityModel {
+  date: string;
+  checks: number;
+}
+
+export interface EvolutionImpactModel {
+  skillName: string;
+  passRateBefore: number;
+  passRateAfter: number;
+  improvement: number;
+}
+
+export interface AnalyticsSummaryModel {
+  activeSkills: number;
+  totalChecks30d: number;
+  totalEvolutions: number;
+  avgImprovement: number;
+}
+
+export interface AnalyticsModel {
+  summary: AnalyticsSummaryModel;
+  passRateTrend: PassRateTrendPointModel[];
+  skillRankings: SkillRankingModel[];
+  dailyActivity: DailyActivityModel[];
+  evolutionImpact: EvolutionImpactModel[];
+}

package/packages/dashboard-core/src/models/index.ts

@@ -0,0 +1,4 @@
+export * from "./analytics";
+export * from "./overview";
+export * from "./runtime";
+export * from "./skills";

package/packages/dashboard-core/src/models/overview.ts

@@ -0,0 +1,98 @@
+export type OverviewAutonomyLevel = "healthy" | "watching" | "needs_review" | "blocked";
+export type OverviewSeverity = "critical" | "warning" | "info";
+export type OverviewTrustBucket = "at_risk" | "improving" | "uncertain" | "stable";
+export type OverviewDecisionKind =
+  | "proposal_created"
+  | "proposal_rejected"
+  | "validation_failed"
+  | "proposal_deployed"
+  | "rollback_triggered"
+  | "regression_found";
+
+export interface OverviewSummaryModel {
+  totalSkills: number;
+  avgPassRate30d: number | null;
+  unmatchedCount30d: number;
+  sessionsCount30d: number;
+  pendingCount: number;
+  evidenceCount: number;
+}
+
+export interface OverviewAutonomyModel {
+  level: OverviewAutonomyLevel;
+  summary: string;
+  attentionRequired: number;
+  skillsObserved: number;
+  pendingReviews: number;
+  lastRunAt: string | null;
+}
+
+export interface OverviewWatchlistEntryModel {
+  skillName: string;
+  bucket: OverviewTrustBucket;
+  lastSeen: string | null;
+  passRate: number | null;
+  checks: number;
+}
+
+export interface OverviewAttentionItemModel {
+  skillName: string;
+  severity: OverviewSeverity;
+  title: string;
+  body: string;
+}
+
+export interface OverviewDecisionModel {
+  skillName: string;
+  kind: OverviewDecisionKind;
+  timestamp: string;
+  summary: string;
+}
+
+export interface OverviewActivityItemModel {
+  id: string;
+  type: "evolution" | "proposal" | "unmatched";
+  skillName?: string;
+  timestamp: string;
+  title: string;
+  summary: string;
+}
+
+export interface PipelineJobModel {
+  id: string;
+  label: string;
+  status: "healthy" | "warning" | "error" | "idle";
+  lastRunAt?: string | null;
+  nextRunAt?: string | null;
+}
+
+export interface OverviewSignalsSummaryModel {
+  signalCount: number;
+  skillCount: number;
+}
+
+export interface OverviewSkillCardModel {
+  id?: string;
+  name: string;
+  scope: string | null;
+  platforms: string[];
+  passRate: number | null;
+  checks: number;
+  status: "HEALTHY" | "WARNING" | "CRITICAL" | "UNKNOWN";
+  hasEvidence: boolean;
+  uniqueSessions: number;
+  lastSeen: string | null;
+}
+
+export interface OverviewModel {
+  version?: string;
+  summary: OverviewSummaryModel;
+  autonomy: OverviewAutonomyModel | null;
+  skillCards: OverviewSkillCardModel[];
+  watchlist: OverviewWatchlistEntryModel[];
+  attention: OverviewAttentionItemModel[];
+  decisions: OverviewDecisionModel[];
+  activity: OverviewActivityItemModel[];
+  jobs: PipelineJobModel[];
+  signals: OverviewSignalsSummaryModel | null;
+}

package/packages/dashboard-core/src/models/runtime.ts

@@ -0,0 +1,7 @@
+export interface RuntimeHealthModel {
+  workspaceRoot: string;
+  gitSha: string;
+  dbPath: string;
+  processMode: string;
+  watcherMode: "wal" | "jsonl" | "none";
+}

package/packages/dashboard-core/src/models/skills.ts

@@ -0,0 +1,34 @@
+export type SkillHealthStatus = "HEALTHY" | "WARNING" | "CRITICAL" | "UNKNOWN";
+
+export interface SkillListItemModel {
+  id?: string;
+  name: string;
+  platforms: string[];
+  status: SkillHealthStatus;
+  passRate: number | null;
+  totalChecks: number;
+  uniqueSessions: number;
+  evidenceCount?: number;
+  lastSeen: string | null;
+}
+
+export interface SkillTrendPointModel {
+  date: string;
+  passRate: number | null;
+  checks: number;
+}
+
+export interface SkillDetailModel {
+  id?: string;
+  name: string;
+  status: SkillHealthStatus;
+  passRate: number | null;
+  totalChecks: number;
+  uniqueSessions: number;
+  lastSeen: string | null;
+  trends: SkillTrendPointModel[];
+}
+
+export interface SkillsModel {
+  items: SkillListItemModel[];
+}

package/packages/dashboard-core/src/routes/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./manifest";

package/packages/dashboard-core/src/routes/manifest.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+
+import type { Capabilities } from "../host/capabilities";
+import { resolveDashboardRoutes } from "./manifest";
+
+const LOCAL_CAPABILITIES: Capabilities = {
+  host: "local",
+  plan: "oss",
+  features: {
+    analytics: true,
+    registry: false,
+    signals: false,
+    proposals: false,
+    billing: false,
+    teamAdmin: false,
+    runtimeStatus: true,
+  },
+  discoverable: {
+    registry: true,
+    signals: true,
+    proposals: true,
+    billing: false,
+  },
+};
+
+const CLOUD_CAPABILITIES: Capabilities = {
+  host: "cloud",
+  plan: "team",
+  features: {
+    analytics: true,
+    registry: true,
+    signals: true,
+    proposals: true,
+    billing: true,
+    teamAdmin: false,
+    runtimeStatus: false,
+  },
+  discoverable: {
+    registry: true,
+    signals: true,
+    proposals: true,
+    billing: true,
+  },
+};
+
+describe("resolveDashboardRoutes", () => {
+  it("keeps signals, proposals, and registry as locked host-only cloud modules in local", () => {
+    const routes = resolveDashboardRoutes("local", LOCAL_CAPABILITIES);
+    const byId = new Map(routes.map((route) => [route.id, route]));
+
+    expect(byId.get("signals")?.access).toBe("locked");
+    expect(byId.get("proposals")?.access).toBe("locked");
+    expect(byId.get("registry")?.access).toBe("locked");
+    expect(byId.get("status")?.access).toBe("enabled");
+    expect(byId.has("unmatched")).toBe(false);
+    expect(byId.has("settings")).toBe(false);
+  });
+
+  it("keeps status local-only and enables the cloud coordination modules in cloud", () => {
+    const routes = resolveDashboardRoutes("cloud", CLOUD_CAPABILITIES);
+    const byId = new Map(routes.map((route) => [route.id, route]));
+
+    expect(byId.get("signals")?.access).toBe("enabled");
+    expect(byId.get("proposals")?.access).toBe("enabled");
+    expect(byId.get("registry")?.access).toBe("enabled");
+    expect(byId.get("unmatched")?.access).toBe("enabled");
+    expect(byId.get("settings")?.access).toBe("enabled");
+    expect(byId.has("status")).toBe(false);
+  });
+});