@happyvertical/smrt-workbench 0.40.66

package/src/runtime.ts

@@ -0,0 +1,165 @@
+import type {
+  ResolvedWorkbenchModule,
+  ResolvedWorkbenchRouteEntry,
+  SmrtWorkbenchModule,
+  SmrtWorkbenchModuleExport,
+  SmrtWorkbenchRouteModule,
+} from './types.js';
+import { displayNameForSmrtPackage } from './utils.js';
+
+export type {
+  ResolvedWorkbenchModule,
+  ResolvedWorkbenchRouteEntry,
+  SmrtWorkbenchModule,
+  SmrtWorkbenchModuleExport,
+  SmrtWorkbenchRouteDefinition,
+  SmrtWorkbenchRouteModule,
+} from './types.js';
+
+export function defineWorkbenchModule(
+  module: SmrtWorkbenchModule,
+): SmrtWorkbenchModule {
+  return module;
+}
+
+export function coerceWorkbenchModules(
+  input: SmrtWorkbenchModuleExport | null | undefined,
+): SmrtWorkbenchModule[] {
+  if (!input) {
+    return [];
+  }
+
+  if (Array.isArray(input)) {
+    return input.filter(Boolean);
+  }
+
+  if ('modules' in input && Array.isArray(input.modules)) {
+    return input.modules.filter(Boolean);
+  }
+
+  return [input as SmrtWorkbenchModule];
+}
+
+function collectRouteModules(
+  module: SmrtWorkbenchModule,
+): SmrtWorkbenchRouteModule[] {
+  return [
+    ...(module.routeModule ? [module.routeModule] : []),
+    ...(module.routeModules || []),
+  ].filter(Boolean);
+}
+
+export function qualifyWorkbenchRouteId(
+  packageName: string,
+  routeId: string,
+): string {
+  return `${packageName}:${routeId}`;
+}
+
+export function workbenchRouteHash(routeId: string): string {
+  return `#${routeId.replace(/[^a-zA-Z0-9_-]+/g, '-')}`;
+}
+
+export function findWorkbenchRouteByHash(
+  routes: ResolvedWorkbenchRouteEntry[],
+  hash: string,
+): ResolvedWorkbenchRouteEntry | null {
+  if (!hash.startsWith('#')) {
+    return null;
+  }
+
+  let fragment: string;
+  try {
+    fragment = decodeURIComponent(hash.slice(1));
+  } catch {
+    return null;
+  }
+  return (
+    routes.find(
+      (route) =>
+        fragment === route.id ||
+        fragment === route.qualifiedId ||
+        `#${fragment}` === workbenchRouteHash(route.id),
+    ) || null
+  );
+}
+
+export function normalizeWorkbenchModule(
+  module: SmrtWorkbenchModule,
+): ResolvedWorkbenchModule {
+  const displayName =
+    module.displayName || displayNameForSmrtPackage(module.packageName);
+  const routeModules = collectRouteModules(module);
+  const routes: ResolvedWorkbenchRouteEntry[] = routeModules
+    .flatMap((routeModule) => {
+      const moduleDisplayName = routeModule.displayName || displayName;
+
+      return Object.entries(routeModule.routes || {}).map(
+        ([routeKey, route]) => {
+          const routeId = route.id || routeKey;
+          return {
+            ...route,
+            packageName: routeModule.packageName || module.packageName,
+            moduleDisplayName,
+            routeKey,
+            qualifiedId: qualifyWorkbenchRouteId(
+              routeModule.packageName || module.packageName,
+              routeId,
+            ),
+            defaultPath: route.defaultPath || `/${routeId}`,
+          };
+        },
+      );
+    })
+    .sort((left, right) => {
+      const leftOrder = left.nav?.order ?? 999;
+      const rightOrder = right.nav?.order ?? 999;
+      const orderDiff = leftOrder - rightOrder;
+      return orderDiff !== 0
+        ? orderDiff
+        : left.title.localeCompare(right.title);
+    });
+
+  return {
+    ...module,
+    displayName,
+    routeModules,
+    routes,
+  };
+}
+
+export function mergeWorkbenchModules(
+  modules: SmrtWorkbenchModule[],
+): ResolvedWorkbenchModule[] {
+  const byPackage = new Map<string, SmrtWorkbenchModule>();
+
+  for (const module of modules) {
+    const existing = byPackage.get(module.packageName);
+    if (!existing) {
+      byPackage.set(module.packageName, { ...module });
+      continue;
+    }
+
+    byPackage.set(module.packageName, {
+      ...existing,
+      ...module,
+      routeModule: undefined,
+      routeModules: [
+        ...(existing.routeModules || []),
+        ...(existing.routeModule ? [existing.routeModule] : []),
+        ...(module.routeModules || []),
+        ...(module.routeModule ? [module.routeModule] : []),
+      ],
+      recommendedCommands: [
+        ...(existing.recommendedCommands || []),
+        ...(module.recommendedCommands || []),
+      ],
+      docs: [...(existing.docs || []), ...(module.docs || [])],
+      examples: [...(existing.examples || []), ...(module.examples || [])],
+    });
+  }
+
+  return [...byPackage.values()]
+    .map((module) => normalizeWorkbenchModule(module))
+    .sort((left, right) => left.displayName.localeCompare(right.displayName));
+}

package/src/types.ts

@@ -0,0 +1,243 @@
+import type { Component } from 'svelte';
+
+export type WorkbenchComponentType = Component<Record<string, unknown>>;
+export type WorkbenchComponentModule =
+  | WorkbenchComponentType
+  | {
+      default: WorkbenchComponentType;
+    };
+
+export type WorkbenchComponentLoader = () => Promise<WorkbenchComponentModule>;
+
+export type SmrtWorkbenchScopeMode = 'workspace' | 'package' | 'consumer';
+export type SmrtWorkbenchPackageManager = 'pnpm' | 'yarn' | 'npm';
+
+export interface SmrtWorkbenchRouteDefinition {
+  id: string;
+  title: string;
+  description?: string;
+  defaultPath?: string;
+  component?: WorkbenchComponentType;
+  loadComponent?: WorkbenchComponentLoader;
+  props?: Record<string, unknown>;
+  tags?: string[];
+  nav?: {
+    label?: string;
+    description?: string;
+    icon?: string;
+    order?: number;
+    group?: string;
+  };
+}
+
+export interface SmrtWorkbenchRouteModule {
+  packageName: string;
+  displayName?: string;
+  description?: string;
+  routes: Record<string, SmrtWorkbenchRouteDefinition>;
+}
+
+export interface SmrtWorkbenchRecommendedCommand {
+  id: string;
+  label: string;
+  command: string;
+  description?: string;
+}
+
+export interface SmrtWorkbenchModule {
+  packageName: string;
+  displayName?: string;
+  description?: string;
+  routeModule?: SmrtWorkbenchRouteModule;
+  routeModules?: SmrtWorkbenchRouteModule[];
+  recommendedCommands?: SmrtWorkbenchRecommendedCommand[];
+  docs?: WorkbenchDocumentSummary[];
+  examples?: WorkbenchExampleSummary[];
+}
+
+export type SmrtWorkbenchModuleExport =
+  | SmrtWorkbenchModule
+  | SmrtWorkbenchModule[]
+  | {
+      modules: SmrtWorkbenchModule[];
+    };
+
+export interface ResolvedWorkbenchRouteEntry
+  extends SmrtWorkbenchRouteDefinition {
+  packageName: string;
+  moduleDisplayName: string;
+  routeKey: string;
+  qualifiedId: string;
+  defaultPath: string;
+}
+
+export interface ResolvedWorkbenchModule
+  extends Omit<
+    SmrtWorkbenchModule,
+    'displayName' | 'routeModule' | 'routeModules'
+  > {
+  displayName: string;
+  routeModules: SmrtWorkbenchRouteModule[];
+  routes: ResolvedWorkbenchRouteEntry[];
+}
+
+export interface WorkbenchScopeResolution {
+  mode: SmrtWorkbenchScopeMode;
+  cwd: string;
+  projectRoot: string;
+  workspaceRoot?: string;
+  packageName?: string;
+  packageDir?: string;
+  packageManager: SmrtWorkbenchPackageManager;
+}
+
+export interface WorkbenchDocumentSummary {
+  kind: 'readme' | 'agents' | 'changelog' | 'generated' | 'docs' | 'other';
+  title: string;
+  path: string;
+  content?: string;
+  truncated?: boolean;
+}
+
+export interface WorkbenchExampleSummary {
+  id: string;
+  title: string;
+  path?: string;
+  language?: string;
+  code?: string;
+  source: 'file' | 'readme' | 'playground';
+}
+
+export interface WorkbenchKnowledgeSummary {
+  manifestPath?: string;
+  knowledgePath?: string;
+  objectCount: number;
+  relationshipCount: number;
+  promptCount: number;
+  mcpToolCount: number;
+  surfaceCount: number;
+  tags: string[];
+  risks: string[];
+  objectNames: string[];
+}
+
+export interface WorkbenchApiObjectFieldSummary {
+  name: string;
+  type?: string;
+  required?: boolean;
+  related?: string;
+  description?: string;
+}
+
+export interface WorkbenchApiObjectSummary {
+  name: string;
+  className?: string;
+  qualifiedName?: string;
+  collection?: string;
+  sourcePath?: string;
+  typedocPath?: string;
+  description?: string;
+  fields: WorkbenchApiObjectFieldSummary[];
+}
+
+export type WorkbenchApiParameterLocation =
+  | 'path'
+  | 'query'
+  | 'body'
+  | 'option'
+  | 'argument'
+  | 'input';
+
+export interface WorkbenchApiParameterSummary {
+  name: string;
+  type?: string;
+  required?: boolean;
+  location: WorkbenchApiParameterLocation;
+  description?: string;
+  defaultValue?: string;
+}
+
+export interface WorkbenchRestEndpointSummary {
+  objectName: string;
+  action: string;
+  method: string;
+  path: string;
+  description: string;
+  parameters: WorkbenchApiParameterSummary[];
+}
+
+export interface WorkbenchCliCommandSummary {
+  objectName: string;
+  action: string;
+  command: string;
+  description: string;
+  parameters: WorkbenchApiParameterSummary[];
+}
+
+export interface WorkbenchMcpToolSummary {
+  objectName: string;
+  action: string;
+  toolName: string;
+  description: string;
+  parameters: WorkbenchApiParameterSummary[];
+}
+
+export interface WorkbenchApiSummary {
+  objectNames: string[];
+  objects: WorkbenchApiObjectSummary[];
+  restEndpoints: WorkbenchRestEndpointSummary[];
+  cliCommands: WorkbenchCliCommandSummary[];
+  mcpTools: WorkbenchMcpToolSummary[];
+  endpointCount: number;
+  routeFiles: string[];
+}
+
+export interface WorkbenchPackageSummary {
+  name: string;
+  version?: string;
+  description?: string;
+  source: 'workspace' | 'package' | 'app';
+  directory?: string;
+  relativeDirectory?: string;
+  scripts: Record<string, string>;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+  smrtDependencies: string[];
+  sdkDependencies: string[];
+  exportKeys: string[];
+  docs: WorkbenchDocumentSummary[];
+  examples: WorkbenchExampleSummary[];
+  knowledge: WorkbenchKnowledgeSummary;
+  api: WorkbenchApiSummary;
+  migrations: string[];
+  routeModuleCount: number;
+  routeCount: number;
+  playgroundEntryCount: number;
+  recommendedCommands: SmrtWorkbenchRecommendedCommand[];
+}
+
+export interface SmrtWorkbenchProject {
+  generatedAt: string;
+  scope: WorkbenchScopeResolution;
+  packages: WorkbenchPackageSummary[];
+}
+
+export interface DiscoveredWorkbenchTarget {
+  packageName?: string;
+  source: 'workspace' | 'package' | 'app';
+  sourcePath?: string;
+  runtimePath?: string;
+  importSpecifier?: string;
+}
+
+export interface SmrtWorkbenchVitePluginOptions {
+  mode?: 'auto' | 'workspace' | 'consumer';
+  projectRoot?: string;
+  workspaceRoot?: string;
+  cwd?: string;
+  packageName?: string;
+  packagesPattern?: string;
+  localWorkbenchPath?: string;
+  localPlaygroundPath?: string;
+}

package/src/utils.ts

@@ -0,0 +1,16 @@
+export function displayNameForSmrtPackage(packageName: string): string {
+  const baseName = packageName
+    .replace(/^@happyvertical\/smrt-/, '')
+    .replace(/^@happyvertical\/smrt$/, 'SMRT')
+    .replace(/^smrt-/, '');
+
+  return baseName
+    .split(/[-_]/g)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+}
+
+export function commandIdForScript(packageName: string, scriptName: string) {
+  return `${packageName}:${scriptName}`;
+}