optimal-cli 1.0.0 → 1.0.1

package/dist/lib/bot/protocol.d.ts

@@ -0,0 +1,12 @@
+export interface AgentMessage {
+    type: 'heartbeat' | 'claim' | 'progress' | 'complete' | 'blocked' | 'release';
+    agentId: string;
+    taskId?: string;
+    payload?: Record<string, unknown>;
+}
+export interface AgentResponse {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+export declare function processAgentMessage(msg: AgentMessage): Promise<AgentResponse>;

package/dist/lib/bot/protocol.js

@@ -0,0 +1,74 @@
+import { sendHeartbeat } from './heartbeat.js';
+import { claimNextTask, releaseTask } from './claim.js';
+import { reportProgress, reportCompletion, reportBlocked } from './reporter.js';
+// --- Message processor ---
+export async function processAgentMessage(msg) {
+    try {
+        switch (msg.type) {
+            case 'heartbeat':
+                return await handleHeartbeat(msg);
+            case 'claim':
+                return await handleClaim(msg);
+            case 'progress':
+                return await handleProgress(msg);
+            case 'complete':
+                return await handleComplete(msg);
+            case 'blocked':
+                return await handleBlocked(msg);
+            case 'release':
+                return await handleRelease(msg);
+            default:
+                return { success: false, error: `Unknown message type: ${msg.type}` };
+        }
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        return { success: false, error: errorMsg };
+    }
+}
+// --- Handlers ---
+async function handleHeartbeat(msg) {
+    const status = msg.payload?.status ?? 'idle';
+    await sendHeartbeat(msg.agentId, status);
+    return { success: true, data: { agentId: msg.agentId, status } };
+}
+async function handleClaim(msg) {
+    const skills = msg.payload?.skills;
+    const task = await claimNextTask(msg.agentId, skills);
+    if (!task) {
+        return { success: true, data: null };
+    }
+    return { success: true, data: { taskId: task.id, title: task.title } };
+}
+async function handleProgress(msg) {
+    if (!msg.taskId) {
+        return { success: false, error: 'taskId is required for progress messages' };
+    }
+    const message = msg.payload?.message ?? 'Progress update';
+    await reportProgress(msg.taskId, msg.agentId, message);
+    return { success: true, data: { taskId: msg.taskId } };
+}
+async function handleComplete(msg) {
+    if (!msg.taskId) {
+        return { success: false, error: 'taskId is required for complete messages' };
+    }
+    const summary = msg.payload?.summary ?? 'Task completed';
+    await reportCompletion(msg.taskId, msg.agentId, summary);
+    return { success: true, data: { taskId: msg.taskId, status: 'done' } };
+}
+async function handleBlocked(msg) {
+    if (!msg.taskId) {
+        return { success: false, error: 'taskId is required for blocked messages' };
+    }
+    const reason = msg.payload?.reason ?? 'No reason given';
+    await reportBlocked(msg.taskId, msg.agentId, reason);
+    return { success: true, data: { taskId: msg.taskId, status: 'blocked' } };
+}
+async function handleRelease(msg) {
+    if (!msg.taskId) {
+        return { success: false, error: 'taskId is required for release messages' };
+    }
+    const reason = msg.payload?.reason;
+    const task = await releaseTask(msg.taskId, msg.agentId, reason);
+    return { success: true, data: { taskId: task.id, status: 'ready' } };
+}

package/dist/lib/bot/reporter.d.ts

@@ -0,0 +1,3 @@
+export declare function reportProgress(taskId: string, agentId: string, message: string): Promise<void>;
+export declare function reportCompletion(taskId: string, agentId: string, summary: string): Promise<void>;
+export declare function reportBlocked(taskId: string, agentId: string, reason: string): Promise<void>;

package/dist/lib/bot/reporter.js

@@ -0,0 +1,27 @@
+import { addComment, updateTask, completeTask } from '../board/index.js';
+export async function reportProgress(taskId, agentId, message) {
+    await addComment({
+        task_id: taskId,
+        author: agentId,
+        body: message,
+        comment_type: 'comment',
+    });
+}
+export async function reportCompletion(taskId, agentId, summary) {
+    await completeTask(taskId, agentId);
+    await addComment({
+        task_id: taskId,
+        author: agentId,
+        body: summary,
+        comment_type: 'status_change',
+    });
+}
+export async function reportBlocked(taskId, agentId, reason) {
+    await updateTask(taskId, { status: 'blocked' }, agentId);
+    await addComment({
+        task_id: taskId,
+        author: agentId,
+        body: `Blocked: ${reason}`,
+        comment_type: 'status_change',
+    });
+}

package/dist/lib/bot/skills.d.ts

@@ -0,0 +1,26 @@
+import type { Task } from '../board/types.js';
+export interface AgentProfile {
+    id: string;
+    skills: string[];
+    maxConcurrent: number;
+    status: 'idle' | 'working' | 'error';
+}
+/**
+ * Reads agent profiles from agents/profiles.json.
+ * Falls back to a single default wildcard profile if the file doesn't exist.
+ */
+export declare function getAgentProfiles(): AgentProfile[];
+/**
+ * Filters and ranks tasks an agent can work on.
+ *
+ * - Includes tasks whose skill_required is in the agent's skills list,
+ *   or tasks with no skill_required, or if agent has wildcard '*'.
+ * - Sorts by priority (P1 first), then sort_order.
+ * - Returns at most agent.maxConcurrent tasks.
+ */
+export declare function matchTasksToAgent(agent: AgentProfile, tasks: Task[]): Task[];
+/**
+ * Finds the first idle agent whose skills match the task's skill_required.
+ * Returns null if no suitable idle agent exists.
+ */
+export declare function findBestAgent(profiles: AgentProfile[], task: Task): AgentProfile | null;

package/dist/lib/bot/skills.js

@@ -0,0 +1,69 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const DEFAULT_PROFILE = {
+    id: 'default',
+    skills: ['*'],
+    maxConcurrent: 1,
+    status: 'idle',
+};
+/**
+ * Reads agent profiles from agents/profiles.json.
+ * Falls back to a single default wildcard profile if the file doesn't exist.
+ */
+export function getAgentProfiles() {
+    const root = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+    const profilesPath = resolve(root, 'agents', 'profiles.json');
+    if (!existsSync(profilesPath)) {
+        return [DEFAULT_PROFILE];
+    }
+    try {
+        const raw = readFileSync(profilesPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch {
+        return [DEFAULT_PROFILE];
+    }
+}
+/**
+ * Filters and ranks tasks an agent can work on.
+ *
+ * - Includes tasks whose skill_required is in the agent's skills list,
+ *   or tasks with no skill_required, or if agent has wildcard '*'.
+ * - Sorts by priority (P1 first), then sort_order.
+ * - Returns at most agent.maxConcurrent tasks.
+ */
+export function matchTasksToAgent(agent, tasks) {
+    const hasWildcard = agent.skills.includes('*');
+    const matched = tasks.filter((t) => {
+        if (hasWildcard)
+            return true;
+        if (!t.skill_required)
+            return true;
+        return agent.skills.includes(t.skill_required);
+    });
+    matched.sort((a, b) => {
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        return a.sort_order - b.sort_order;
+    });
+    return matched.slice(0, agent.maxConcurrent);
+}
+/**
+ * Finds the first idle agent whose skills match the task's skill_required.
+ * Returns null if no suitable idle agent exists.
+ */
+export function findBestAgent(profiles, task) {
+    for (const agent of profiles) {
+        if (agent.status !== 'idle')
+            continue;
+        if (agent.skills.includes('*'))
+            return agent;
+        if (!task.skill_required)
+            return agent;
+        if (agent.skills.includes(task.skill_required))
+            return agent;
+    }
+    return null;
+}

package/dist/lib/budget/projections.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Budget projection calculator for FY26 planning
+ *
+ * Ported from wes-dashboard/src/lib/projections/calculator.ts
+ * Pure TypeScript — no React, no framework deps.
+ *
+ * Supports two adjustment types:
+ * - Percentage: projected = actual * (1 + rate/100)
+ * - Flat: projected = actual + flatAmount
+ *
+ * Supports both unit AND average retail projections for revenue forecasting.
+ *
+ * Data sources:
+ * - Supabase `fpa_wes_imports` table (ReturnPro instance)
+ * - JSON file from stdin or --file flag
+ */
+export interface CheckedInUnitsSummary {
+    programCode: string;
+    masterProgram: string;
+    masterProgramId: number | null;
+    clientId: number | null;
+    clientName: string;
+    unitCount: number;
+    countMethod: 'Unit' | 'Pallet';
+    avgRetail?: number;
+    monthLabel?: string;
+}
+export interface ProjectionEntry {
+    programCode: string;
+    masterProgram: string;
+    masterProgramId: number | null;
+    clientId: number | null;
+    clientName: string;
+    actualUnits: number;
+    adjustmentType: 'percentage' | 'flat';
+    adjustmentValue: number;
+    projectedUnits: number;
+    avgRetail?: number;
+    avgRetailAdjustmentType: 'percentage' | 'flat';
+    avgRetailAdjustmentValue: number;
+    projectedAvgRetail?: number;
+}
+export interface ProjectionInput {
+    actualUnits: number;
+    adjustmentType: 'percentage' | 'flat';
+    adjustmentValue: number;
+}
+export interface ProjectionTotals {
+    totalActual: number;
+    totalProjected: number;
+    percentageChange: number;
+    absoluteChange: number;
+    actualRevenue: number;
+    projectedRevenue: number;
+    revenueChange: number;
+    revenuePercentChange: number;
+}
+/**
+ * Calculate projected units based on adjustment type and value.
+ */
+export declare function calculateProjection(input: ProjectionInput): number;
+/**
+ * Calculate projected average retail price.
+ */
+export declare function calculateAvgRetailProjection(actualAvgRetail: number | undefined, adjustmentType: 'percentage' | 'flat', adjustmentValue: number): number | undefined;
+/**
+ * Convert checked-in units summary to projection entries with default values (0% change).
+ */
+export declare function initializeProjections(summary: CheckedInUnitsSummary[]): ProjectionEntry[];
+/**
+ * Update a single projection entry's units.
+ */
+export declare function updateProjection(entry: ProjectionEntry, adjustmentType: 'percentage' | 'flat', adjustmentValue: number): ProjectionEntry;
+/**
+ * Update a single projection entry's average retail.
+ */
+export declare function updateAvgRetailProjection(entry: ProjectionEntry, adjustmentType: 'percentage' | 'flat', adjustmentValue: number): ProjectionEntry;
+/**
+ * Apply a uniform unit adjustment to all projections.
+ */
+export declare function applyUniformAdjustment(projections: ProjectionEntry[], adjustmentType: 'percentage' | 'flat', adjustmentValue: number): ProjectionEntry[];
+/**
+ * Apply a uniform avg retail adjustment to all projections.
+ */
+export declare function applyUniformAvgRetailAdjustment(projections: ProjectionEntry[], adjustmentType: 'percentage' | 'flat', adjustmentValue: number): ProjectionEntry[];
+/**
+ * Calculate totals for projection summary including revenue.
+ */
+export declare function calculateTotals(projections: ProjectionEntry[]): ProjectionTotals;
+/**
+ * Group projections by client name.
+ */
+export declare function groupProjectionsByClient(projections: ProjectionEntry[]): Map<string, ProjectionEntry[]>;
+/**
+ * Export projections to CSV format with unit + avgRetail + inventory value data.
+ */
+export declare function exportToCSV(projections: ProjectionEntry[]): string;
+/**
+ * Fetch FY25 actuals from fpa_wes_imports on the ReturnPro Supabase instance.
+ * Aggregates across all months for a given fiscal year and user,
+ * returning one CheckedInUnitsSummary per master program.
+ */
+export declare function fetchWesImports(options?: {
+    fiscalYear?: number;
+    userId?: string;
+}): Promise<CheckedInUnitsSummary[]>;
+/**
+ * Parse a JSON file (array of CheckedInUnitsSummary) as an alternative data source.
+ * Accepts raw JSON string (e.g., from stdin or file read).
+ */
+export declare function parseSummaryFromJson(json: string): CheckedInUnitsSummary[];
+/**
+ * Format projections as a Bloomberg-dense markdown table.
+ */
+export declare function formatProjectionTable(projections: ProjectionEntry[]): string;