agentic-orchestrator 0.1.27 → 0.2.0

package/packages/web-dashboard/src/lib/dashboard-utils.ts

@@ -1,15 +1,28 @@
 import type { DashboardStatusPayload, FeatureSummary } from '@/lib/types.js';
 
 export const COLUMN_ORDER: Array<{ title: string; phase: FeatureSummary['phase'] }> = [
+  { title: 'Intake', phase: 'intake' },
   { title: 'Planning', phase: 'planning' },
   { title: 'Building', phase: 'building' },
   { title: 'QA', phase: 'qa' },
   { title: 'Ready to Merge', phase: 'ready_to_merge' },
+  { title: 'Awaiting Input', phase: 'awaiting_input' },
   { title: 'Blocked', phase: 'blocked' },
+];
+
+export const FILTERABLE_PHASE_ORDER: Array<{ title: string; phase: FeatureSummary['phase'] }> = [
+  ...COLUMN_ORDER,
   { title: 'Merged', phase: 'merged' },
 ];
 
 export type QuickFilterKey =
+  | 'needs_me'
+  | 'at_risk'
+  | 'ready'
+  | 'stalled'
+  | 'waiting_on_dependencies'
+  | 'waiting_on_ci'
+  | 'recently_changed'
   | 'active'
   | 'blocked'
   | 'awaiting_input'
@@ -48,10 +61,12 @@ export interface ColumnFeatureIds {
 }
 
 const PHASE_VALUES: PhaseFilterValue[] = [
+  'intake',
   'planning',
   'building',
   'qa',
   'ready_to_merge',
+  'awaiting_input',
   'merged',
   'blocked',
   'unknown',
@@ -67,12 +82,24 @@ const ACTIVITY_VALUES: NonNullable<FeatureSummary['activity_state']>[] = [
 ];
 
 export interface DashboardSummaryCounts {
-  active: number;
-  blocked: number;
-  awaitingInput: number;
-  readyToMerge: number;
-  ciFailing: number;
-}
+  needsMe: number;
+  atRisk: number;
+  ready: number;
+  stalled: number;
+  waitingOnDependencies: number;
+  waitingOnCi: number;
+  recentlyChanged: number;
+}
+
+export const TASK_FILTER_OPTIONS: Array<{ key: QuickFilterKey; label: string }> = [
+  { key: 'needs_me', label: 'Needs Me' },
+  { key: 'at_risk', label: 'At Risk' },
+  { key: 'ready', label: 'Ready' },
+  { key: 'stalled', label: 'Stalled' },
+  { key: 'waiting_on_dependencies', label: 'Waiting On Dependencies' },
+  { key: 'waiting_on_ci', label: 'Waiting On CI' },
+  { key: 'recently_changed', label: 'Recently Changed' },
+];
 
 export interface SparklinePoint {
   x: number;
@@ -81,6 +108,9 @@ export interface SparklinePoint {
   index: number;
 }
 
+export const DISPLAYED_GATE_MODES = ['plan', 'fast', 'full', 'merge'] as const;
+export type DisplayedGateMode = (typeof DISPLAYED_GATE_MODES)[number];
+
 export interface ParsedDiffLine {
   raw: string;
   type: 'add' | 'del' | 'context' | 'meta';
@@ -134,6 +164,13 @@ function parseBooleanFlag(value: string | null): boolean {
 
 function isQuickFilterKey(value: string): value is QuickFilterKey {
   return (
+    value === 'needs_me' ||
+    value === 'at_risk' ||
+    value === 'ready' ||
+    value === 'stalled' ||
+    value === 'waiting_on_dependencies' ||
+    value === 'waiting_on_ci' ||
+    value === 'recently_changed' ||
     value === 'active' ||
     value === 'blocked' ||
     value === 'awaiting_input' ||
@@ -284,7 +321,7 @@ export function buildFeatureFocusHref(featureId: string, project: string): strin
 }
 
 export function isQuickLaunchAffordanceVisible(state: QuickLaunchAffordanceState): boolean {
-  return state.available && state.enabled && state.authorized;
+  return state.available || !state.enabled || !state.authorized;
 }
 
 function findCurrentColumnIndex(
@@ -374,8 +411,22 @@ export function applyQuickFilter(key: QuickFilterKey): DashboardFilterState {
   const next = createDefaultFilters();
   next.quickFilter = key;
 
-  if (key === 'active') {
-    next.phases = ['planning', 'building', 'qa', 'ready_to_merge'];
+  if (key === 'needs_me') {
+    next.activities = ['waiting_input'];
+  } else if (key === 'at_risk') {
+    next.gateFailuresOnly = true;
+  } else if (key === 'ready') {
+    next.phases = ['ready_to_merge'];
+  } else if (key === 'stalled') {
+    next.quickFilter = 'stalled';
+  } else if (key === 'waiting_on_dependencies') {
+    next.quickFilter = 'waiting_on_dependencies';
+  } else if (key === 'waiting_on_ci') {
+    next.quickFilter = 'waiting_on_ci';
+  } else if (key === 'recently_changed') {
+    next.quickFilter = 'recently_changed';
+  } else if (key === 'active') {
+    next.phases = ['intake', 'planning', 'building', 'qa', 'ready_to_merge'];
   } else if (key === 'blocked') {
     next.phases = ['blocked'];
   } else if (key === 'awaiting_input') {
@@ -395,7 +446,8 @@ export function filtersAreActive(filters: DashboardFilterState): boolean {
     filters.phases.length > 0 ||
     filters.activities.length > 0 ||
     filters.gateFailuresOnly ||
-    filters.ciFailuresOnly
+    filters.ciFailuresOnly ||
+    filters.quickFilter != null
   );
 }
 
@@ -422,9 +474,10 @@ function normalizeGateStatus(value: unknown): 'pass' | 'fail' | 'na' {
 
 export function getGateMap(
   feature: FeatureSummary,
-): Record<'fast' | 'full' | 'merge', 'pass' | 'fail' | 'na'> {
+): Record<DisplayedGateMode, 'pass' | 'fail' | 'na'> {
   const gateSource = feature.gates && typeof feature.gates === 'object' ? feature.gates : {};
   return {
+    plan: normalizeGateStatus((gateSource as Record<string, unknown>).plan),
     fast: normalizeGateStatus((gateSource as Record<string, unknown>).fast),
     full: normalizeGateStatus((gateSource as Record<string, unknown>).full),
     merge: normalizeGateStatus((gateSource as Record<string, unknown>).merge),
@@ -433,7 +486,12 @@ export function getGateMap(
 
 export function hasGateFailure(feature: FeatureSummary): boolean {
   const gates = getGateMap(feature);
-  return gates.fast === 'fail' || gates.full === 'fail' || gates.merge === 'fail';
+  return (
+    gates.plan === 'fail' ||
+    gates.fast === 'fail' ||
+    gates.full === 'fail' ||
+    gates.merge === 'fail'
+  );
 }
 
 export function normalizeCiStatus(
@@ -470,15 +528,115 @@ export function isCiNotSuccess(status: string | undefined | null): boolean {
 
 export function computeSummaryCounts(payload: DashboardStatusPayload): DashboardSummaryCounts {
   return {
-    active: Array.isArray(payload.index.active) ? payload.index.active.length : 0,
-    blocked: payload.features.filter((feature) => feature.phase === 'blocked').length,
-    awaitingInput: payload.features.filter((feature) => feature.activity_state === 'waiting_input')
+    needsMe: payload.features.filter((feature) => matchesQuickFilter(feature, 'needs_me')).length,
+    atRisk: payload.features.filter((feature) => matchesQuickFilter(feature, 'at_risk')).length,
+    ready: payload.features.filter((feature) => matchesQuickFilter(feature, 'ready')).length,
+    stalled: payload.features.filter((feature) => matchesQuickFilter(feature, 'stalled')).length,
+    waitingOnDependencies: payload.features.filter((feature) =>
+      matchesQuickFilter(feature, 'waiting_on_dependencies'),
+    ).length,
+    waitingOnCi: payload.features.filter((feature) => matchesQuickFilter(feature, 'waiting_on_ci'))
       .length,
-    readyToMerge: payload.features.filter((feature) => feature.phase === 'ready_to_merge').length,
-    ciFailing: payload.features.filter((feature) => isCiFailing(feature.pr?.ci_status)).length,
+    recentlyChanged: payload.features.filter((feature) =>
+      matchesQuickFilter(feature, 'recently_changed'),
+    ).length,
   };
 }
 
+function hasAttentionReason(feature: FeatureSummary, label: string): boolean {
+  return feature.attention_reasons?.includes(label) ?? false;
+}
+
+export function matchesQuickFilter(feature: FeatureSummary, key: QuickFilterKey): boolean {
+  if (key === 'needs_me' || key === 'awaiting_input') {
+    return feature.activity_state === 'waiting_input' || (feature.waiting_input_count ?? 0) > 0;
+  }
+  if (key === 'at_risk') {
+    return (
+      feature.phase === 'blocked' ||
+      hasGateFailure(feature) ||
+      feature.budget_state === 'critical' ||
+      feature.budget_state === 'exceeded' ||
+      hasAttentionReason(feature, 'At Risk')
+    );
+  }
+  if (key === 'ready' || key === 'ready_to_merge') {
+    return feature.phase === 'ready_to_merge';
+  }
+  if (key === 'stalled') {
+    return hasAttentionReason(feature, 'Stalled');
+  }
+  if (key === 'waiting_on_dependencies') {
+    return hasAttentionReason(feature, 'Waiting On Dependencies');
+  }
+  if (key === 'waiting_on_ci') {
+    return (
+      hasAttentionReason(feature, 'Waiting On CI') ||
+      normalizeCiStatus(feature.pr?.ci_status) === 'pending'
+    );
+  }
+  if (key === 'recently_changed') {
+    return hasAttentionReason(feature, 'Recently Changed');
+  }
+  if (key === 'active') {
+    return ['intake', 'planning', 'building', 'qa', 'ready_to_merge'].includes(
+      feature.phase ?? 'unknown',
+    );
+  }
+  if (key === 'blocked') {
+    return feature.phase === 'blocked';
+  }
+  if (key === 'ci_failing') {
+    return isCiFailing(feature.pr?.ci_status);
+  }
+  return true;
+}
+
+function featureRank(feature: FeatureSummary): number {
+  if (matchesQuickFilter(feature, 'needs_me')) {
+    return 0;
+  }
+  if (matchesQuickFilter(feature, 'at_risk')) {
+    return 1;
+  }
+  if (matchesQuickFilter(feature, 'ready')) {
+    return 2;
+  }
+  if (matchesQuickFilter(feature, 'stalled')) {
+    return 3;
+  }
+  if (matchesQuickFilter(feature, 'waiting_on_dependencies')) {
+    return 4;
+  }
+  if (matchesQuickFilter(feature, 'waiting_on_ci')) {
+    return 5;
+  }
+  if (matchesQuickFilter(feature, 'recently_changed')) {
+    return 6;
+  }
+  if (feature.phase === 'merged') {
+    return 9;
+  }
+  return 7;
+}
+
+export function sortFeaturesForTriage(features: FeatureSummary[]): FeatureSummary[] {
+  return [...features].sort((left, right) => {
+    const rankDelta = featureRank(left) - featureRank(right);
+    if (rankDelta !== 0) {
+      return rankDelta;
+    }
+    const rightUpdated = right.last_meaningful_change_at ?? right.last_updated ?? '';
+    const leftUpdated = left.last_meaningful_change_at ?? left.last_updated ?? '';
+    const rightMs = Date.parse(rightUpdated);
+    const leftMs = Date.parse(leftUpdated);
+    if (!Number.isNaN(rightMs) && !Number.isNaN(leftMs) && rightMs !== leftMs) {
+      return rightMs - leftMs;
+    }
+    return left.feature_id.localeCompare(right.feature_id);
+  });
+}
+
 export function filterFeatures(
   features: FeatureSummary[],
   filters: DashboardFilterState,
@@ -504,7 +662,10 @@ export function filterFeatures(
       return filters.activities.includes(feature.activity_state ?? 'unknown');
     })
     .filter((feature) => !filters.gateFailuresOnly || hasGateFailure(feature))
-    .filter((feature) => !filters.ciFailuresOnly || isCiNotSuccess(feature.pr?.ci_status));
+    .filter((feature) => !filters.ciFailuresOnly || isCiNotSuccess(feature.pr?.ci_status))
+    .filter((feature) =>
+      filters.quickFilter ? matchesQuickFilter(feature, filters.quickFilter) : true,
+    );
 }
 
 function relativeUnit(value: number, unit: Intl.RelativeTimeFormatUnit): string {

package/packages/web-dashboard/src/lib/drop-zone-utils.ts

@@ -0,0 +1,92 @@
+/**
+ * Recursively collects .md files from a list of DataTransferItem entries.
+ * Handles both direct file drops and folder drops via webkitGetAsEntry().
+ */
+
+function isMarkdownFile(name: string): boolean {
+  return name.endsWith('.md');
+}
+
+function readEntriesPromise(reader: FileSystemDirectoryReader): Promise<FileSystemEntry[]> {
+  return new Promise((resolve, reject) => {
+    reader.readEntries(resolve, reject);
+  });
+}
+
+function fileEntryToFile(entry: FileSystemFileEntry): Promise<File> {
+  return new Promise((resolve, reject) => {
+    entry.file(resolve, reject);
+  });
+}
+
+async function walkEntry(entry: FileSystemEntry, files: File[]): Promise<void> {
+  if (entry.isFile) {
+    if (isMarkdownFile(entry.name)) {
+      const file = await fileEntryToFile(entry as FileSystemFileEntry);
+      files.push(file);
+    }
+    return;
+  }
+  if (entry.isDirectory) {
+    const reader = (entry as FileSystemDirectoryEntry).createReader();
+    let batch = await readEntriesPromise(reader);
+    while (batch.length > 0) {
+      for (const child of batch) {
+        await walkEntry(child, files);
+      }
+      batch = await readEntriesPromise(reader);
+    }
+  }
+}
+
+export interface DropResult {
+  markdownFiles: File[];
+  skippedNonMarkdownCount: number;
+}
+
+export async function collectMarkdownFromDrop(items: DataTransferItemList): Promise<DropResult> {
+  const files: File[] = [];
+  let skippedNonMarkdownCount = 0;
+
+  const entries: Array<{ entry: FileSystemEntry | null; item: DataTransferItem }> = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (item.kind !== 'file') {
+      continue;
+    }
+    const entry = typeof item.webkitGetAsEntry === 'function' ? item.webkitGetAsEntry() : null;
+    entries.push({ entry, item });
+  }
+
+  for (const { entry, item } of entries) {
+    if (entry?.isDirectory) {
+      await walkEntry(entry, files);
+    } else if (entry?.isFile) {
+      if (isMarkdownFile(entry.name)) {
+        const file = await fileEntryToFile(entry as FileSystemFileEntry);
+        files.push(file);
+      } else {
+        skippedNonMarkdownCount++;
+      }
+    } else {
+      // Fallback: no webkitGetAsEntry support — use getAsFile()
+      const file = item.getAsFile();
+      if (file) {
+        if (isMarkdownFile(file.name)) {
+          files.push(file);
+        } else {
+          skippedNonMarkdownCount++;
+        }
+      }
+    }
+  }
+
+  return { markdownFiles: files, skippedNonMarkdownCount };
+}
+
+export function supportsDirectoryDrop(): boolean {
+  if (typeof DataTransferItem === 'undefined') {
+    return false;
+  }
+  return typeof DataTransferItem.prototype.webkitGetAsEntry === 'function';
+}