@pellux/goodvibes-agent 1.4.1 → 1.4.2

package/src/input/commands/work-plan-runtime.ts

@@ -1,191 +0,0 @@
-import type { CommandRegistry } from '../command-registry.ts';
-import type { WorkPlanItemStatus, WorkPlanStore } from '../../work-plans/work-plan-store.ts';
-import { WORK_PLAN_STATUSES } from '../../work-plans/work-plan-store.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { requireYesFlag, stripYesFlag } from './confirmation.ts';
-
-const STATUS_COMMANDS: Record<string, WorkPlanItemStatus> = {
-  pending: 'pending',
-  todo: 'pending',
-  start: 'in_progress',
-  active: 'in_progress',
-  progress: 'in_progress',
-  block: 'blocked',
-  blocked: 'blocked',
-  done: 'done',
-  complete: 'done',
-  fail: 'failed',
-  failed: 'failed',
-  cancel: 'cancelled',
-  cancelled: 'cancelled',
-};
-
-function getStore(ctx: import('../command-registry.ts').CommandContext): WorkPlanStore | null {
-  return ctx.workspace.workPlanStore ?? null;
-}
-
-function formatList(store: WorkPlanStore): string {
-  const items = store.listItems();
-  if (items.length === 0) {
-    return [
-      'Work plan is empty',
-      '  next /workplan add <title>',
-    ].join('\n');
-  }
-  return [
-    `Work Plan (${items.length})`,
-    ...items.map((item) => {
-      const owner = item.owner ? ` @${item.owner}` : '';
-      return `  ${item.id}  ${item.status.padEnd(11)} ${item.title}${owner}`;
-    }),
-  ].join('\n');
-}
-
-function parseAddArgs(args: string[]): { title: string; owner?: string; source?: string; notes?: string } {
-  const titleParts: string[] = [];
-  let owner: string | undefined;
-  let source: string | undefined;
-  let notes: string | undefined;
-  for (let i = 0; i < args.length; i++) {
-    const part = args[i] ?? '';
-    if (part === '--owner' && args[i + 1]) {
-      owner = args[++i];
-      continue;
-    }
-    if (part === '--source' && args[i + 1]) {
-      source = args[++i];
-      continue;
-    }
-    if (part === '--notes' && args[i + 1]) {
-      notes = args.slice(i + 1).join(' ').trim();
-      break;
-    }
-    titleParts.push(part);
-  }
-  return {
-    title: titleParts.join(' ').trim(),
-    ...(owner ? { owner } : {}),
-    ...(source ? { source } : {}),
-    ...(notes ? { notes } : {}),
-  };
-}
-
-export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'workplan',
-    aliases: ['wp', 'todo'],
-    description: 'Track a persistent workspace-scoped work plan',
-    usage: '[list|show|add <title> [--owner name] [--source label] [--notes text]|done <id>|start <id>|block <id>|fail <id>|cancel <id>|pending <id>|remove <id> --yes|clear-done --yes]',
-    argsHint: '[list|add|show|done]',
-    handler(args, ctx) {
-      const parsed = stripYesFlag(args);
-      const commandArgs = [...parsed.rest];
-      const store = getStore(ctx);
-      if (!store) {
-        ctx.print('Work plan store is not available in this runtime.');
-        return;
-      }
-      const subcommand = (commandArgs[0] ?? 'list').toLowerCase();
-      try {
-        if (subcommand === 'panel' || subcommand === 'open') {
-          ctx.print('Open Agent Workspace -> Work -> Work plan for the workspace view, or run /workplan list for compact command output.');
-          return;
-        }
-        if (subcommand === 'list') {
-          ctx.print(formatList(store));
-          return;
-        }
-        if (subcommand === 'show' || subcommand === 'markdown') {
-          ctx.print(store.toMarkdown());
-          return;
-        }
-        if (subcommand === 'add') {
-          const addArgs = parseAddArgs(commandArgs.slice(1));
-          if (!addArgs.title) {
-            ctx.print('Usage: /workplan add <title> [--owner name] [--source label] [--notes text]');
-            return;
-          }
-          const addOptions = {
-            ...(addArgs.owner ? { owner: addArgs.owner } : {}),
-            source: addArgs.source ?? 'manual',
-            ...(addArgs.notes ? { notes: addArgs.notes } : {}),
-          };
-          const item = store.addItem(addArgs.title, addOptions);
-          ctx.print([
-            'Added work plan item',
-            `  id ${item.id}`,
-            `  title ${item.title}`,
-            '  next open Agent Workspace -> Work -> Work plan to review',
-          ].join('\n'));
-          return;
-        }
-        if (subcommand === 'remove' || subcommand === 'delete' || subcommand === 'rm') {
-          const id = commandArgs[1];
-          if (!id) {
-            ctx.print(`Usage: /workplan ${subcommand} <id> --yes`);
-            return;
-          }
-          if (!parsed.yes) {
-            requireYesFlag(ctx, `remove work plan item ${id}`, `/workplan ${subcommand} <id> --yes`);
-            return;
-          }
-          const item = store.removeItem(id);
-          ctx.print([
-            'Removed work plan item',
-            `  id ${item.id}`,
-            `  title ${item.title}`,
-          ].join('\n'));
-          return;
-        }
-        if (subcommand === 'clear-done' || subcommand === 'clear-completed') {
-          if (!parsed.yes) {
-            requireYesFlag(ctx, 'clear completed work plan items', `/workplan ${subcommand} --yes`);
-            return;
-          }
-          const count = store.clearCompleted();
-          ctx.print([
-            'Cleared completed/cancelled work plan items',
-            `  count ${count}`,
-          ].join('\n'));
-          return;
-        }
-        if (subcommand === 'cycle' || subcommand === 'toggle') {
-          const id = commandArgs[1];
-          if (!id) {
-            ctx.print(`Usage: /workplan ${subcommand} <id>`);
-            return;
-          }
-          const item = store.cycleItemStatus(id);
-          ctx.print([
-            'Updated work plan item',
-            `  id ${item.id}`,
-            `  status ${item.status}`,
-          ].join('\n'));
-          return;
-        }
-        const status = STATUS_COMMANDS[subcommand];
-        if (status) {
-          const id = commandArgs[1];
-          if (!id) {
-            ctx.print(`Usage: /workplan ${subcommand} <id>`);
-            return;
-          }
-          const item = store.setItemStatus(id, status);
-          ctx.print([
-            'Updated work plan item',
-            `  id ${item.id}`,
-            `  status ${item.status}`,
-          ].join('\n'));
-          return;
-        }
-        if (WORK_PLAN_STATUSES.includes(subcommand as WorkPlanItemStatus)) {
-          ctx.print(`Usage: /workplan ${subcommand} <id>`);
-          return;
-        }
-        ctx.print(`Unknown workplan subcommand ${subcommand}`);
-      } catch (error) {
-        ctx.print(summarizeError(error));
-      }
-    },
-  });
-}

package/src/panels/plan-dashboard-panel.ts

@@ -1,274 +0,0 @@
-import type { Line } from '../types/grid.ts';
-import type { ExecutionPlan, PlanItem, PlanItemStatus } from '@pellux/goodvibes-sdk/platform/core';
-import { BasePanel } from './base-panel.ts';
-import type { PlanDashboardQuery } from '../runtime/ui-service-queries.ts';
-import {
-  buildEmptyState,
-  buildPanelLine,
-  buildPanelWorkspace,
-  resolveScrollablePanelSection,
-  DEFAULT_PANEL_PALETTE,
-  type PanelWorkspaceSection,
-} from './polish.ts';
-
-// ---------------------------------------------------------------------------
-// Status display maps
-// ---------------------------------------------------------------------------
-
-const STATUS_ICON: Record<PlanItemStatus, string> = {
-  complete: '✓',
-  in_progress: '▸',
-  pending: '•',
-  failed: '✗',
-  skipped: '–',
-};
-
-const STATUS_FG: Record<PlanItemStatus, string> = {
-  complete: '#22c55e',
-  in_progress: '#00ffff',
-  pending: '244',
-  failed: '#ef4444',
-  skipped: '238',
-};
-
-// ---------------------------------------------------------------------------
-// PlanDashboardPanel
-// ---------------------------------------------------------------------------
-
-export class PlanDashboardPanel extends BasePanel {
-  private scrollOffset = 0;
-  private selectedIndex = 0;
-
-  // Flat list of navigable row indices (set during render)
-  private totalRows = 0;
-  private readonly planManager: PlanDashboardQuery;
-
-  constructor(planManager: PlanDashboardQuery) {
-    super('plan', 'Plan', 'P', 'agent');
-    this.planManager = planManager;
-  }
-
-  override onActivate(): void {
-    super.onActivate();
-    // Re-read plan from disk each time the panel is activated
-    this.markDirty();
-  }
-
-  // --------------------------------------------------------------------------
-  // Input
-  // --------------------------------------------------------------------------
-
-  handleInput(key: string): boolean {
-    if (key === 'up' || key === 'k') {
-      if (this.selectedIndex > 0) {
-        this.selectedIndex--;
-        this.markDirty();
-        return true;
-      }
-    } else if (key === 'down' || key === 'j') {
-      if (this.selectedIndex < this.totalRows - 1) {
-        this.selectedIndex++;
-        this.markDirty();
-        return true;
-      }
-    }
-    return false;
-  }
-
-  // --------------------------------------------------------------------------
-  // Render
-  // --------------------------------------------------------------------------
-
-  render(width: number, height: number): Line[] {
-    return this.trackedRender(() => {
-    const plan = this.planManager.getActive();
-    if (!plan) {
-      return buildPanelWorkspace(width, height, {
-        title: ' Plan Dashboard',
-        intro: 'Track the active execution plan, item status, phase grouping, and overall completion.',
-        sections: [
-          {
-            lines: buildEmptyState(
-              width,
-              ' No active execution plan',
-              'Use /plan to create a plan and the execution dashboard will populate here.',
-              [],
-              DEFAULT_PANEL_PALETTE,
-            ),
-          },
-        ],
-        palette: DEFAULT_PANEL_PALETTE,
-      });
-    }
-    return this.renderPlan(plan, width, height);
-    });
-  }
-
-  // --------------------------------------------------------------------------
-  // Empty state
-  // --------------------------------------------------------------------------
-
-  private renderPlan(plan: ExecutionPlan, width: number, height: number): Line[] {
-    const phaseOrder: string[] = [];
-    const byPhase = new Map<string, PlanItem[]>();
-    for (const item of plan.items) {
-      if (!byPhase.has(item.phase)) {
-        byPhase.set(item.phase, []);
-        phaseOrder.push(item.phase);
-      }
-      byPhase.get(item.phase)!.push(item);
-    }
-
-    // Build a set of complete item IDs for dependency blocking detection
-    const completeIds = new Set(
-      plan.items
-        .filter((i) => i.status === 'complete' || i.status === 'skipped')
-        .map((i) => i.id),
-    );
-
-    let rowCount = 0;
-    let selectedLineIndex = 0;
-    const planLines: Line[] = [];
-
-    for (const phase of phaseOrder) {
-      const items = byPhase.get(phase)!;
-      planLines.push(this.renderPhaseHeaderLine(phase, items, width));
-      for (const item of items) {
-        const isSelected = rowCount === this.selectedIndex;
-        if (isSelected) selectedLineIndex = planLines.length;
-        const isBlocked =
-          item.status === 'pending' &&
-          item.dependencies !== undefined &&
-          item.dependencies.length > 0 &&
-          !item.dependencies.every((depId) => completeIds.has(depId));
-
-        planLines.push(this.renderItem(item, isSelected, isBlocked, width));
-        rowCount++;
-      }
-    }
-
-    this.totalRows = rowCount;
-    if (this.selectedIndex >= this.totalRows) {
-      this.selectedIndex = Math.max(0, this.totalRows - 1);
-    }
-
-    const total = plan.items.length;
-    const done = plan.items.filter((i) => i.status === 'complete' || i.status === 'skipped').length;
-    const pct = total > 0 ? Math.round((done / total) * 100) : 0;
-    const summary: PanelWorkspaceSection = {
-      title: 'Summary',
-      lines: [
-        buildPanelLine(width, [
-          [' Status ', DEFAULT_PANEL_PALETTE.label],
-          [plan.status, this.statusColor(plan.status)],
-          ['   Progress ', DEFAULT_PANEL_PALETTE.label],
-          [`${pct}%`, pct === 100 ? DEFAULT_PANEL_PALETTE.good : DEFAULT_PANEL_PALETTE.info],
-          ['   Items ', DEFAULT_PANEL_PALETTE.label],
-          [`${done}/${total}`, DEFAULT_PANEL_PALETTE.value],
-        ]),
-      ],
-    };
-
-    const planSection = resolveScrollablePanelSection(width, height, {
-      intro: plan.title,
-      footerLines: [
-        buildPanelLine(width, [[' Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim]]),
-      ],
-      palette: DEFAULT_PANEL_PALETTE,
-      beforeSections: [summary],
-      section: {
-        title: 'Execution Plan',
-        scrollableLines: planLines,
-        selectedIndex: selectedLineIndex,
-        scrollOffset: this.scrollOffset,
-        minRows: 8,
-      },
-    });
-    this.scrollOffset = planSection.scrollOffset;
-
-    return buildPanelWorkspace(width, height, {
-      title: ` Plan Dashboard`,
-      intro: plan.title,
-      sections: [
-        summary,
-        planSection.section,
-      ],
-      footerLines: [
-        buildPanelLine(width, [[' Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim]]),
-      ],
-      palette: DEFAULT_PANEL_PALETTE,
-    });
-  }
-
-  // --------------------------------------------------------------------------
-  // Header — title + overall completion percentage
-  // --------------------------------------------------------------------------
-
-  private renderPhaseHeaderLine(phase: string, items: PlanItem[], width: number): Line {
-    const done = items.filter(
-      (i) => i.status === 'complete' || i.status === 'skipped',
-    ).length;
-    const total = items.length;
-    const active = items.some((i) => i.status === 'in_progress');
-    const failed = items.some((i) => i.status === 'failed');
-
-    const phaseFg = failed ? '#ef4444' : active ? '#00ffff' : done === total ? '#22c55e' : '250';
-
-    const barW = 8;
-    const filledB = total > 0 ? Math.round((done / total) * barW) : 0;
-    const bar = '#'.repeat(filledB) + '-'.repeat(barW - filledB);
-
-    const progressText = `[${bar}] ${done}/${total}`;
-    const phaseText = ` > ${phase}`;
-    const spacer = Math.max(1, width - phaseText.length - progressText.length - 1);
-    return buildPanelLine(width, [
-      [phaseText, phaseFg],
-      [' '.repeat(spacer), phaseFg],
-      [progressText, phaseFg],
-      [' ', phaseFg],
-    ]);
-  }
-
-  // --------------------------------------------------------------------------
-  // Individual item
-  // --------------------------------------------------------------------------
-
-  private renderItem(
-    item: PlanItem,
-    isSelected: boolean,
-    isBlocked: boolean,
-    width: number,
-  ): Line {
-    const icon = STATUS_ICON[item.status];
-    const fg = isBlocked ? '238' : STATUS_FG[item.status];
-    const dim = item.status === 'skipped' || isBlocked;
-
-    // Indent blocked items to visually signal they depend on others
-    const indent = isBlocked ? '      ' : '   ';
-    const selectedMark = isSelected ? '▸' : ' ';
-
-    let text = `${selectedMark}${indent}${icon} ${item.description}`;
-
-    // Append agent ID for in-progress and complete items
-    if (item.agentId && (item.status === 'in_progress' || item.status === 'complete')) {
-      text += ` [${item.agentId}]`;
-    }
-
-    // Append dependency note for blocked items (first unmet dep description)
-    if (isBlocked && item.dependencies && item.dependencies.length > 0) {
-      text += ' (blocked)';
-    }
-
-    return buildPanelLine(width, [[text, fg, isSelected ? '#1e293b' : undefined]]);
-  }
-
-  private statusColor(status: ExecutionPlan['status']): string {
-    return status === 'complete'
-      ? DEFAULT_PANEL_PALETTE.good
-      : status === 'failed'
-      ? DEFAULT_PANEL_PALETTE.bad
-      : status === 'active'
-      ? DEFAULT_PANEL_PALETTE.info
-      : DEFAULT_PANEL_PALETTE.dim;
-  }
-}