agentic-orchestrator 0.1.28 → 0.2.0

package/packages/web-dashboard/src/lib/launch-contracts.ts

@@ -0,0 +1,77 @@
+import path from 'node:path';
+
+export const SUPPORTED_LAUNCH_EXTENSIONS = ['.md'] as const;
+
+export type LaunchDraftSourceType = 'upload' | 'paste';
+
+export interface LaunchDraftInput {
+  draft_id: string;
+  draft_order: number;
+  source_type: LaunchDraftSourceType;
+  name: string;
+  markdown: string;
+  source_path?: string | null;
+}
+
+export interface LaunchDraftPreview {
+  draft_id: string;
+  feature_id: string | null;
+  canonical_spec_path: string | null;
+  preview_html: string;
+  preview_mode: 'rendered' | 'fallback';
+  warnings: string[];
+  errors: string[];
+}
+
+export interface LaunchSubmitOutcome {
+  draft_id: string;
+  feature_id: string | null;
+  canonical_spec_path: string | null;
+  status: 'submitted' | 'invalid' | 'skipped';
+  request_id?: string | null;
+  request_status?: string | null;
+  warnings: string[];
+  errors: string[];
+}
+
+function hasSupportedExtension(name: string): boolean {
+  return SUPPORTED_LAUNCH_EXTENSIONS.includes(path.extname(name).toLowerCase() as '.md');
+}
+
+export function validateLaunchDraftInput(draft: LaunchDraftInput): string[] {
+  const errors: string[] = [];
+
+  if (draft.draft_id.trim().length === 0) {
+    errors.push('draft_id is required.');
+  }
+
+  if (!Number.isFinite(draft.draft_order)) {
+    errors.push('draft_order must be a finite number.');
+  }
+
+  if (draft.name.trim().length === 0) {
+    errors.push('Draft name is required.');
+  }
+
+  if (draft.markdown.trim().length === 0) {
+    errors.push('Draft markdown is required.');
+  }
+
+  if (draft.source_type === 'upload' && !hasSupportedExtension(draft.name)) {
+    errors.push('Only .md draft uploads are supported.');
+  }
+
+  return errors;
+}
+
+export function sortLaunchDrafts<T extends { draft_order: number; feature_id?: string | null }>(
+  drafts: T[],
+): T[] {
+  return [...drafts].sort((left, right) => {
+    const orderDelta = left.draft_order - right.draft_order;
+    if (orderDelta !== 0) {
+      return orderDelta;
+    }
+    return (left.feature_id ?? '').localeCompare(right.feature_id ?? '');
+  });
+}

package/packages/web-dashboard/src/lib/launch-markdown.ts

@@ -0,0 +1,107 @@
+import { Marked, type Token, type Tokens } from 'marked';
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function sanitizeHref(value: string): string | null {
+  if (!value.startsWith('http://') && !value.startsWith('https://')) {
+    return null;
+  }
+  try {
+    return new URL(value).toString();
+  } catch {
+    return null;
+  }
+}
+
+function slugifyHeading(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+interface RendererContext {
+  parser: {
+    parseInline(tokens: Token[]): string;
+  };
+}
+
+const markdownParser = new Marked({
+  async: false,
+  breaks: false,
+  gfm: true,
+});
+
+markdownParser.use({
+  renderer: {
+    heading(this: RendererContext, token: Tokens.Heading): string {
+      const level = Math.min(token.depth + 1, 4);
+      return `<h${level} id="${slugifyHeading(token.text)}">${this.parser.parseInline(token.tokens)}</h${level}>`;
+    },
+    html(token: Tokens.HTML | Tokens.Tag): string {
+      return escapeHtml(token.text);
+    },
+    image(token: Tokens.Image): string {
+      return escapeHtml(token.text);
+    },
+    link(this: RendererContext, token: Tokens.Link): string {
+      const safeHref = sanitizeHref(token.href);
+      const label = this.parser.parseInline(token.tokens);
+      if (safeHref == null) {
+        return label;
+      }
+      const titleAttribute = token.title != null ? ` title="${escapeHtml(token.title)}"` : '';
+      return `<a href="${escapeHtml(safeHref)}"${titleAttribute} target="_blank" rel="noreferrer">${label}</a>`;
+    },
+    table(this: RendererContext, token: Tokens.Table): string {
+      const header = token.header
+        .map((cell) => `<th>${this.parser.parseInline(cell.tokens)}</th>`)
+        .join('');
+      const rows = token.rows
+        .map(
+          (row) =>
+            `<tr>${row
+              .map((cell) => `<td>${this.parser.parseInline(cell.tokens)}</td>`)
+              .join('')}</tr>`,
+        )
+        .join('');
+      return `<div class="markdownTableWrapper"><table><thead><tr>${header}</tr></thead><tbody>${rows}</tbody></table></div>`;
+    },
+  },
+});
+
+export interface MarkdownPreviewResult {
+  html: string;
+  mode: 'rendered' | 'fallback';
+  warnings: string[];
+}
+
+export function renderLaunchMarkdown(markdown: string): MarkdownPreviewResult {
+  const warnings: string[] = [];
+
+  if (markdown.includes('<') || markdown.includes('>')) {
+    warnings.push('Raw HTML was escaped in preview.');
+  }
+
+  const fenceCount = (markdown.match(/```/g) ?? []).length;
+  if (fenceCount % 2 !== 0) {
+    return {
+      html: `<pre>${escapeHtml(markdown)}</pre>`,
+      mode: 'fallback',
+      warnings: ['Preview fell back to escaped raw markdown because a code fence is not closed.'],
+    };
+  }
+
+  return {
+    html: markdownParser.parse(markdown, { async: false }),
+    mode: 'rendered',
+    warnings,
+  };
+}

package/packages/web-dashboard/src/lib/launch-page-preview.ts

@@ -0,0 +1,89 @@
+import type { LaunchDraftCardState } from '@/components/launch/launch-draft-card.js';
+import type { LaunchDraftInput } from '@/lib/launch-contracts.js';
+
+interface PreviewResponse {
+  ok: boolean;
+  data?: {
+    drafts: Array<
+      Pick<
+        LaunchDraftCardState,
+        | 'draft_id'
+        | 'feature_id'
+        | 'canonical_spec_path'
+        | 'preview_html'
+        | 'preview_mode'
+        | 'warnings'
+        | 'errors'
+      >
+    >;
+  };
+}
+
+function toLaunchDraftInput(draft: LaunchDraftCardState, draftOrder: number): LaunchDraftInput {
+  return {
+    draft_id: draft.draft_id,
+    draft_order: draftOrder,
+    source_type: draft.source_type,
+    name: draft.name,
+    markdown: draft.markdown,
+    source_path: draft.source_path ?? draft.name,
+  };
+}
+
+function stringArraysEqual(left: string[], right: string[]): boolean {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+export function buildLaunchPreviewDrafts(drafts: LaunchDraftCardState[]): LaunchDraftInput[] {
+  return drafts.map((draft, index) => toLaunchDraftInput(draft, index));
+}
+
+export function buildLaunchPreviewKey(previewDrafts: LaunchDraftInput[]): string {
+  return JSON.stringify(previewDrafts);
+}
+
+export function applyLaunchPreview(
+  current: LaunchDraftCardState[],
+  previews: NonNullable<PreviewResponse['data']>['drafts'],
+): LaunchDraftCardState[] {
+  const previewsById = new Map(previews.map((preview) => [preview.draft_id, preview]));
+  let changed = false;
+  const next = current.map((draft) => {
+    const preview = previewsById.get(draft.draft_id);
+    if (!preview) {
+      return draft;
+    }
+
+    const unchanged =
+      draft.feature_id === preview.feature_id &&
+      draft.canonical_spec_path === preview.canonical_spec_path &&
+      draft.preview_html === preview.preview_html &&
+      draft.preview_mode === preview.preview_mode &&
+      stringArraysEqual(draft.warnings, preview.warnings) &&
+      stringArraysEqual(draft.errors, preview.errors);
+
+    if (unchanged) {
+      return draft;
+    }
+
+    changed = true;
+    return {
+      ...draft,
+      feature_id: preview.feature_id,
+      canonical_spec_path: preview.canonical_spec_path,
+      preview_html: preview.preview_html,
+      preview_mode: preview.preview_mode,
+      warnings: preview.warnings,
+      errors: preview.errors,
+    };
+  });
+
+  return changed ? next : current;
+}
+
+export function toLaunchSubmitDraftInput(
+  draft: LaunchDraftCardState,
+  draftOrder: number,
+): LaunchDraftInput {
+  return toLaunchDraftInput(draft, draftOrder);
+}

package/packages/web-dashboard/src/lib/live-feed.ts

@@ -15,7 +15,7 @@ function gateHasFailure(feature: FeatureSummary): boolean {
   if (!gates || typeof gates !== 'object') {
     return false;
   }
-  return [gates.fast, gates.full, gates.merge].some((value) => {
+  return [gates.plan, gates.fast, gates.full, gates.merge].some((value) => {
     if (typeof value !== 'string') {
       return false;
     }

package/packages/web-dashboard/src/lib/multi-project-config.ts

@@ -24,6 +24,12 @@ export interface MultiProjectDashboardConfig {
   projects: Array<{
     name: string;
     path: string;
+    label?: string;
+    environment?: string;
+    owner?: string;
+    sort_order?: number;
+    pinned?: boolean;
+    hidden?: boolean;
     policy?: string;
     gates?: string;
     dashboard_port?: number;
@@ -56,6 +62,12 @@ function parseConfig(raw: string, repoRoot: string): MultiProjectDashboardConfig
     projects?: Array<{
       name?: unknown;
       path?: unknown;
+      label?: unknown;
+      environment?: unknown;
+      owner?: unknown;
+      sort_order?: unknown;
+      pinned?: unknown;
+      hidden?: unknown;
       policy?: unknown;
       gates?: unknown;
       dashboard_port?: unknown;
@@ -82,6 +94,12 @@ function parseConfig(raw: string, repoRoot: string): MultiProjectDashboardConfig
       return {
         name: project.name as string,
         path: absoluteProjectPath,
+        label: typeof project.label === 'string' ? project.label : undefined,
+        environment: typeof project.environment === 'string' ? project.environment : undefined,
+        owner: typeof project.owner === 'string' ? project.owner : undefined,
+        sort_order: typeof project.sort_order === 'number' ? project.sort_order : undefined,
+        pinned: project.pinned === true,
+        hidden: project.hidden === true,
         policy: policyPath,
         gates: gatesPath,
         dashboard_port:
@@ -89,6 +107,21 @@ function parseConfig(raw: string, repoRoot: string): MultiProjectDashboardConfig
       };
     });
 
+  projects.sort((left, right) => {
+    if ((left.hidden ?? false) !== (right.hidden ?? false)) {
+      return left.hidden ? 1 : -1;
+    }
+    if ((left.pinned ?? false) !== (right.pinned ?? false)) {
+      return left.pinned ? -1 : 1;
+    }
+    const leftOrder = left.sort_order ?? Number.MAX_SAFE_INTEGER;
+    const rightOrder = right.sort_order ?? Number.MAX_SAFE_INTEGER;
+    if (leftOrder !== rightOrder) {
+      return leftOrder - rightOrder;
+    }
+    return left.name.localeCompare(right.name);
+  });
+
   return {
     defaults: candidate.defaults,
     projects,