@stephen-netu/design-system 0.1.0 → 0.2.1

package/src/entity-graph-view/types.ts

@@ -1,364 +0,0 @@
-// Entity Graph View — SOVEREIGN Entity Graph Visualization Types
-// Maps m0-primitives entity types to LEAP visualization components
-//
-// IMPORTANT: These types match the serde serialization output from Rust.
-// Rust uses snake_case fields and externally tagged enum variants by default.
-
-import type { GraphSchema, NodeInstance, NodeDefinition, EdgeDefinition } from '../n0-node-graph/types';
-import type { MetricCardProps, TimelineEntry } from '../d0-data-viz/types';
-
-// === Serde-compatible SOVEREIGN Entity Types ===
-//
-// Rust newtype wrappers (EntityId, EdgeId) serialize as plain strings.
-// Rust enums serialize as externally tagged: { "Custom": "foo" }, { "Active": null }
-// Rust BTreeMap serializes as plain JSON object, not TS Map.
-// Rust BTreeSet serializes as JSON array.
-// Rust u64 serializes as JSON number.
-
-export type EntityId = string;
-export type EdgeId = string;
-
-// Enums — externally tagged per serde default
-export type EntityType = { Custom: string };
-export type RelationshipType = { Custom: string };
-export type MetricType = { Custom: string };
-
-export type EntityState =
-  | { Active: null }
-  | { Inactive: null }
-  | { Degraded: null }
-  | { Critical: null }
-  | { Pending: null }
-  | { Resolved: null }
-  | { Custom: string };
-
-export type MetricValue =
-  | { Scalar: number }
-  | { Distribution: number[] }
-  | { TimeSeries: [number, number][] };
-
-// === Core Domain Structs (snake_case matches Rust) ===
-
-export interface WorldEntity {
-  id: EntityId;
-  entity_type: EntityType;
-  canonical_name: string;
-  display_name: string;
-  properties: Record<string, unknown>;
-  state: EntityState;
-  created_sequence: number;
-  updated_sequence: number;
-  tags: string[];
-}
-
-export interface WorldEdge {
-  id: EdgeId;
-  source: EntityId;
-  target: EntityId;
-  relationship: RelationshipType;
-  properties: Record<string, unknown>;
-  weight: number;
-  created_sequence: number;
-}
-
-export interface WorldMetric {
-  entity_id: EntityId;
-  metric_type: MetricType;
-  value: MetricValue;
-  unit: string;
-  timestamp_sequence: number;
-  source: string;
-}
-
-export interface StateTransition {
-  entity_id: EntityId;
-  from_state: EntityState;
-  to_state: EntityState;
-  trigger: string;
-  sequence: number;
-  metadata: Record<string, unknown>;
-}
-
-export interface WorldSnapshot {
-  sequence: number;
-  // BTreeMap serializes as plain JSON object
-  entities: Record<EntityId, WorldEntity>;
-  edges: Record<EdgeId, WorldEdge>;
-  // BTreeMap<EntityId, BTreeMap<String, Vec<WorldMetric>>>
-  metrics: Record<EntityId, Record<string, WorldMetric[]>>;
-  transitions: StateTransition[];
-}
-
-// === Delta / Anomaly / MetricDelta (for streaming updates) ===
-
-/** The delta between two snapshots — used for incremental updates. */
-export interface WorldDelta {
-  since_sequence: number;
-  until_sequence: number;
-  added_entities: EntityId[];
-  modified_entities: EntityId[];
-  removed_entities: EntityId[];
-  added_edges: EdgeId[];
-  removed_edges: EdgeId[];
-  // BTreeMap<EntityId, Vec<WorldMetric>>
-  new_metrics: Record<EntityId, WorldMetric[]>;
-  new_transitions: StateTransition[];
-}
-
-/** A detected anomaly on an entity metric. */
-export interface Anomaly {
-  entity_id: EntityId;
-  metric_type: MetricType;
-  description: string;
-  severity: number;
-  sequence: number;
-}
-
-/** The change in a metric over a window. */
-export interface MetricDelta {
-  entity_id: EntityId;
-  metric_type: MetricType;
-  start_value: number;
-  end_value: number;
-  absolute_change: number;
-  percent_change: number;
-  window_start: number;
-  window_end: number;
-}
-
-// === Enum Extractors ===
-
-/** Extract string value from externally-tagged EntityType */
-export function entityTypeStr(t: EntityType): string {
-  return t.Custom;
-}
-
-/** Extract string value from externally-tagged RelationshipType */
-export function relationshipTypeStr(t: RelationshipType): string {
-  return t.Custom;
-}
-
-/** Extract string value from externally-tagged MetricType */
-export function metricTypeStr(t: MetricType): string {
-  return t.Custom;
-}
-
-/** Extract state string from externally-tagged EntityState */
-export function entityStateStr(s: EntityState): string {
-  if ('Active' in s) return 'active';
-  if ('Inactive' in s) return 'inactive';
-  if ('Degraded' in s) return 'degraded';
-  if ('Critical' in s) return 'critical';
-  if ('Pending' in s) return 'pending';
-  if ('Resolved' in s) return 'resolved';
-  if ('Custom' in s) return s.Custom;
-  return 'unknown';
-}
-
-/** Extract scalar value from MetricValue, if scalar */
-export function metricValueScalar(v: MetricValue): number | null {
-  if ('Scalar' in v) return v.Scalar;
-  return null;
-}
-
-/** Extract latest value from MetricValue */
-export function metricValueLatest(v: MetricValue): number | null {
-  if ('Scalar' in v) return v.Scalar;
-  if ('Distribution' in v) {
-    const d = v.Distribution;
-    return d.length > 0 ? d[d.length - 1] : null;
-  }
-  if ('TimeSeries' in v) {
-    const ts = v.TimeSeries;
-    return ts.length > 0 ? ts[ts.length - 1][1] : null;
-  }
-  return null;
-}
-
-// === State Color Map ===
-
-export const STATE_COLORS: Record<string, string> = {
-  active: '#22c55e',
-  inactive: '#6b7280',
-  degraded: '#f59e0b',
-  critical: '#ef4444',
-  pending: '#3b82f6',
-  resolved: '#10b981',
-};
-
-// === Adapters ===
-
-/**
- * Convert WorldEntity to NodeInstance for n0-node-graph.
- * EntityId is a string, so id maps directly.
- */
-export function entityToNodeInstance(
-  entity: WorldEntity,
-  position: { x: number; y: number } = { x: 0, y: 0 }
-): NodeInstance {
-  return {
-    id: entity.id,
-    kind: entityTypeStr(entity.entity_type),
-    position,
-    size: { width: 200, height: 100 },
-    data: {
-      display_name: entity.display_name,
-      canonical_name: entity.canonical_name,
-      state: entityStateStr(entity.state),
-      tags: entity.tags,
-      ...entity.properties,
-    },
-    collapsed: false,
-  };
-}
-
-/**
- * Convert WorldEdge to EdgeDefinition for n0-node-graph.
- */
-export function edgeToEdgeDefinition(edge: WorldEdge): EdgeDefinition {
-  return {
-    id: edge.id,
-    sourceNodeId: edge.source,
-    sourcePortId: 'output',
-    targetNodeId: edge.target,
-    targetPortId: 'input',
-    metadata: {
-      relationship: relationshipTypeStr(edge.relationship),
-      weight: edge.weight,
-      ...edge.properties,
-    },
-  };
-}
-
-/**
- * Generate NodeDefinition for an entity type.
- * One definition per unique entity_type in the snapshot.
- */
-export function entityTypeToNodeDefinition(entityType: string): NodeDefinition {
-  return {
-    kind: entityType,
-    label: entityType.charAt(0).toUpperCase() + entityType.slice(1),
-    description: `${entityType} entity`,
-    ports: [
-      { id: 'input', label: 'In', type: 'system:edge:default', direction: 'input', required: false, maxConnections: -1 },
-      { id: 'output', label: 'Out', type: 'system:edge:default', direction: 'output', required: false, maxConnections: -1 },
-    ],
-    metadata: {},
-  };
-}
-
-/**
- * Convert WorldSnapshot to GraphSchema with ELK-compatible layout hints.
- * Positions are set to 0,0 — use elkjs for layout before rendering.
- */
-export function snapshotToGraphSchema(snapshot: WorldSnapshot): GraphSchema {
-  // Collect unique entity types for node definitions
-  const typeSet = new Set<string>();
-  Object.values(snapshot.entities).forEach(e => {
-    typeSet.add(entityTypeStr(e.entity_type));
-  });
-  const nodeDefinitions: NodeDefinition[] = Array.from(typeSet).sort().map(entityTypeToNodeDefinition);
-
-  // Create nodes at origin — layout engine positions them
-  const nodes: NodeInstance[] = Object.values(snapshot.entities).map(e =>
-    entityToNodeInstance(e, { x: 0, y: 0 })
-  );
-
-  // Create edges
-  const edges: EdgeDefinition[] = Object.values(snapshot.edges).map(edgeToEdgeDefinition);
-
-  return {
-    id: `entity-graph-${snapshot.sequence}`,
-    name: `Entity Graph #${snapshot.sequence}`,
-    version: '1.0.0',
-    nodeDefinitions,
-    nodes,
-    edges,
-  };
-}
-
-/**
- * Extract latest scalar metrics as MetricCardProps.
- */
-export function snapshotToMetrics(snapshot: WorldSnapshot): MetricCardProps[] {
-  const cards: MetricCardProps[] = [];
-
-  for (const [_entityId, metricMap] of Object.entries(snapshot.metrics)) {
-    for (const [metricTypeKey, metrics] of Object.entries(metricMap)) {
-      if (metrics.length === 0) continue;
-
-      // Find latest by timestamp_sequence
-      const sorted = [...metrics].sort((a, b) => a.timestamp_sequence - b.timestamp_sequence);
-      const latest = sorted[sorted.length - 1];
-      const scalar = metricValueLatest(latest.value);
-      if (scalar === null) continue;
-
-      // Compute trend from last two values
-      let trend: 'up' | 'down' | 'flat' | undefined;
-      if (sorted.length >= 2) {
-        const prev = metricValueLatest(sorted[sorted.length - 2].value);
-        if (prev !== null) {
-          trend = scalar > prev ? 'up' : scalar < prev ? 'down' : 'flat';
-        }
-      }
-
-      cards.push({
-        label: metricTypeKey.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
-        value: scalar.toFixed(2),
-        unit: latest.unit,
-        trend,
-        size: 'default',
-      });
-    }
-  }
-
-  return cards;
-}
-
-/**
- * Convert StateTransitions to TimelineEntries.
- */
-export function snapshotToTimeline(snapshot: WorldSnapshot): TimelineEntry[] {
-  return [...snapshot.transitions]
-    .sort((a, b) => a.sequence - b.sequence)
-    .map(t => ({
-      id: `transition-${t.sequence}-${t.entity_id}`,
-      timestamp: `Seq ${t.sequence}`,
-      label: `${entityStateStr(t.from_state)} → ${entityStateStr(t.to_state)}`,
-      description: `${t.entity_id}: ${t.trigger}`,
-      color: STATE_COLORS[entityStateStr(t.to_state)] ?? '#6b7280',
-    }));
-}
-
-// === Filter ===
-
-export interface EntityFilter {
-  entity_types?: string[];
-  states?: string[];
-  tags_any?: string[];
-  tags_all?: string[];
-  name_contains?: string;
-}
-
-export function filterEntities(entities: WorldEntity[], filter: EntityFilter): WorldEntity[] {
-  return entities.filter(entity => {
-    if (filter.entity_types?.length && !filter.entity_types.includes(entityTypeStr(entity.entity_type))) {
-      return false;
-    }
-    if (filter.states?.length && !filter.states.includes(entityStateStr(entity.state))) {
-      return false;
-    }
-    if (filter.tags_any?.length && !filter.tags_any.some(t => entity.tags.includes(t))) {
-      return false;
-    }
-    if (filter.tags_all?.length && !filter.tags_all.every(t => entity.tags.includes(t))) {
-      return false;
-    }
-    if (filter.name_contains &&
-        !entity.canonical_name.includes(filter.name_contains) &&
-        !entity.display_name.includes(filter.name_contains)) {
-      return false;
-    }
-    return true;
-  });
-}

package/src/epistemic/types.ts

@@ -1,134 +0,0 @@
-// @kos/design-system — Epistemic transparency types
-// Derived from LEAP-EPISTEMIC-TRANSPARENCY-SPEC.md
-
-// --- ASSAY ---
-export interface AssayClearanceView {
-  checkpoint: 'PreIsr' | 'PreMettle' | 'PreEffector' | 'PreKnowledge';
-  gate: 'Cleared' | 'Blocked';
-  severity: 'None' | 'Minor' | 'Medium' | 'High' | 'Critical';
-  weightedSum: number;            // 0.0–1.0
-  signals: AssaySignalView[];
-  computedAt: number;             // deterministic tick
-  isDegraded: boolean;
-}
-
-export interface AssaySignalView {
-  id: 'SaeClarity' | 'SchemaValid' | 'RiskTier' | 'SourceCredibility'
-    | 'SemanticCoherence' | 'CapabilityCheck' | 'FeatureCoverage' | 'NoveltyGate';
-  result: 'Pass' | 'Fail' | 'Unavailable';
-  confidence: number | null;
-  isHardGate: boolean;
-  reason?: string;
-}
-
-// --- ALLAY ---
-export interface AllayStageView {
-  stage: 0 | 1 | 2 | 3 | 4 | 5;
-  confidence: number;             // 0.0–1.0
-  stageName: 'Propose' | 'Parse' | 'Authorize' | 'Execute' | 'Trace' | 'Replicate';
-}
-
-// Mapping from assay_confidence (u8, 0-255) to stage:
-// 0-50:    Stage 0 (Propose)
-// 51-100:  Stage 1 (Parse)
-// 101-150: Stage 2 (Authorize)
-// 151-190: Stage 3 (Execute)
-// 191-230: Stage 4 (Trace)
-// 231-255: Stage 5 (Replicate)
-export function confidenceToStage(confidence: number): AllayStageView {
-  const stage: 0 | 1 | 2 | 3 | 4 | 5 =
-    confidence <= 50 ? 0 :
-    confidence <= 100 ? 1 :
-    confidence <= 150 ? 2 :
-    confidence <= 190 ? 3 :
-    confidence <= 230 ? 4 : 5;
-  const names: AllayStageView['stageName'][] = ['Propose','Parse','Authorize','Execute','Trace','Replicate'];
-  return { stage, confidence: confidence / 255, stageName: names[stage] };
-}
-
-// --- EXPERT ---
-export interface ExpertIdentity {
-  name: 'Atelier' | 'Agora' | 'Ryu' | 'SOVEREIGN' | 'Agent';
-  agentId?: string;
-  domain: string;
-}
-
-// --- AVENUE ---
-// Flat step view — matches the Rust AvenueStepView struct emitted by the Tauri command.
-// Rich per-type fields are NOT present; use step_type + summary for display.
-export interface AvenueStepView {
-  step_type: 'query' | 'retrieve' | 'filter' | 'synthesize' | 'contradict' | 'verify' | string;
-  summary: string;
-}
-
-export interface AvenueTraceView {
-  steps: AvenueStepView[];
-  isPartial: boolean;
-  confidence: number;
-  session_id: string;
-}
-
-// --- PROVENANCE ---
-export type ProvenanceNodeType =
-  | 'human_draft' | 'file_source' | 'web_source' | 'assay_evaluation'
-  | 'sigchain_witness' | 'agent_research' | 'accord_replication'
-  | 'access_epoch' | 'knowledge_merge' | 'supersession';
-
-export interface ProvenanceChainNodeBase {
-  id: string;
-  timestamp: number;
-  expert: ExpertIdentity;
-  previousNodeId: string | null;
-}
-
-export type ProvenanceChainNode = ProvenanceChainNodeBase & (
-  | { type: 'human_draft'; detail: { contentHash: string } }
-  | { type: 'file_source'; detail: { filePath: string; contentHash: string } }
-  | { type: 'web_source'; detail: { url: string; sourceUrlHash: string; sectionId?: string } }
-  | { type: 'assay_evaluation'; detail: { checkpoint: string; gate: string; clearanceHash: string; weightedSum: number } }
-  | { type: 'sigchain_witness'; detail: { witnessRef: string; assayConfidence: number } }
-  | { type: 'agent_research'; detail: { sessionId: string; claimHash: string } }
-  | { type: 'accord_replication'; detail: { accordId: string; sourceRealmId: string } }
-  | { type: 'access_epoch'; detail: { accessCount: number; consolidatorId: string } }
-  | { type: 'knowledge_merge'; detail: { inputHashes: string[] } }
-  | { type: 'supersession'; detail: { supersededHash: string } }
-);
-
-// --- EPISTEMIC DETAIL ---
-export interface KnowledgeEpistemicDetail {
-  contentHash: string;
-  title: string;
-  source: string;
-  // Phase 0: Rust returns null; will be ExpertIdentity once wt-710 is wired.
-  expert?: ExpertIdentity | null;
-  allay: AllayStageView;
-  // Phase 0: Rust returns null; will be non-null once AssayClearanceFor is wired.
-  assay?: AssayClearanceView | null;
-  // Phase 0: Rust returns null; will be ProvenanceChainNode[] once wt-710 is wired.
-  provenance: ProvenanceChainNode[] | null;
-  // Phase 0: Rust returns null; will be AvenueTraceView once wt-711 is wired.
-  avenue?: AvenueTraceView | null;
-  convergence: number;
-}
-
-// --- AGGREGATE STATS ---
-export interface EpistemicStats {
-  totalKnowledge: number;
-  byStage: Record<number, number>;
-  byGate: Record<string, number>;
-  pendingReview: number;
-  averageConfidence: number;
-}
-
-// Rust-side alias (camelCase serde output from EpistemicStatsView).
-// byStage / byGate are stub empty objects until wt-710 daemon aggregate is wired.
-export type EpistemicStatsView = EpistemicStats;
-
-// --- PARADIGM ---
-export interface ParadigmDefinition {
-  id: 'spatial' | 'temporal' | 'hierarchical' | 'graph' | 'trust';
-  label: string;
-  description: string;
-  conceals: string;
-  icon: string;
-}

package/src/epistemic/utils.ts

@@ -1,32 +0,0 @@
-// @kos/design-system — Epistemic shared utilities
-
-import type { ProvenanceChainNode } from './types.js';
-
-/**
- * Returns a human-readable label for a provenance chain node type.
- * Shared by ProvenanceChain and KnowledgeDetailPanel to avoid duplication.
- */
-export function getProvenanceNodeLabel(node: ProvenanceChainNode): string {
-  switch (node.type) {
-    case 'human_draft': return 'Human drafted';
-    case 'file_source': return `File: ${(node.detail as { filePath: string }).filePath}`;
-    case 'web_source': return `Web: ${(node.detail as { url: string }).url}`;
-    case 'assay_evaluation': {
-      const d = node.detail as { checkpoint: string; gate: string; weightedSum: number };
-      return `ASSAY ${d.checkpoint} — ${d.gate} (${(d.weightedSum * 100).toFixed(0)}%)`;
-    }
-    case 'sigchain_witness': {
-      const d = node.detail as { witnessRef: string; assayConfidence: number };
-      return `Witnessed on sigchain — ${d.witnessRef}`;
-    }
-    case 'agent_research': return 'Agent research step';
-    case 'accord_replication': return 'Replicated via Accord';
-    case 'access_epoch': {
-      const d = node.detail as { accessCount: number };
-      return `${d.accessCount} accesses consolidated`;
-    }
-    case 'knowledge_merge': return 'Knowledge merge';
-    case 'supersession': return 'Supersedes prior entry';
-    default: return (node as ProvenanceChainNode).type;
-  }
-}

package/src/f0-forms/validation/validate.ts

@@ -1,47 +0,0 @@
-// F0 Forms — Pure validation utilities
-// Each validator returns null on success, or an error message string on failure.
-
-export type Validator = (value: string) => string | null;
-
-/** Fails if the value is empty or whitespace-only. */
-export function required(value: string): string | null {
-  if (value == null) value = '';
-  return value.trim().length === 0 ? 'This field is required' : null;
-}
-
-/** Returns a validator that fails if value length is below `min`. */
-export function minLength(min: number): Validator {
-  return (value: string) => {
-    if (value == null) value = '';
-    return value.length < min ? `Must be at least ${min} characters` : null;
-  };
-}
-
-/** Returns a validator that fails if value length exceeds `max`. */
-export function maxLength(max: number): Validator {
-  return (value: string) => {
-    if (value == null) value = '';
-    return value.length > max ? `Must be at most ${max} characters` : null;
-  };
-}
-
-/** Returns a validator that fails if value does not match the given regex. */
-export function pattern(regex: RegExp, message: string): Validator {
-  return (value: string) => {
-    if (value == null) value = '';
-    return regex.test(value) ? null : message;
-  };
-}
-
-/** Composes multiple validators, returning the first error encountered or null. */
-export function compose(...validators: Validator[]): Validator {
-  return (value: string) => {
-    for (const validator of validators) {
-      const error = validator(value);
-      if (error !== null) {
-        return error;
-      }
-    }
-    return null;
-  };
-}

package/src/fabric/data/index.ts

@@ -1,21 +0,0 @@
-/**
- * Fabric Data Components
- * 
- * Data visualization and management components.
- */
-
-// IMPLEMENTATION_REQUIRED(sovra-983): FileTree component implementation pending
-// Stub export to resolve type errors - full implementation needed
-
-export interface FileEntry {
-  id: string;
-  name: string;
-  type: 'file' | 'directory';
-  path: string;
-  children?: FileEntry[];
-  isExpanded?: boolean;
-  isSelected?: boolean;
-}
-
-// Stub component - replace with actual implementation
-export const FileTree = null;