logwork-cli 1.1.0 → 1.2.0

package/lib/manual-ink-draft-actions.mjs

@@ -0,0 +1,227 @@
+// Saved-draft actions for the Ink logwork wizard: save, list, resume, delete.
+import { useCallback } from 'react';
+import {
+  buildProjectOptions,
+  buildWeekDateOptions,
+  formatDraftPreview
+} from './manual-logwork-wizard.mjs';
+import { JIRA_TARGET, RO_TARGET } from './manual-targets.mjs';
+import {
+  deleteManualDraft,
+  formatManualDraftLabel,
+  loadManualDrafts,
+  saveManualDraft
+} from './manual-drafts.mjs';
+import { sameProjectIdentity } from './manual-ink-ui.mjs';
+import { clearSessionPreviews } from './manual-ink-session.mjs';
+
+export function useDraftActions(ctx) {
+  const {
+    cwd,
+    sessionRef,
+    wizard,
+    setWizard,
+    setActivePanel,
+    setLoading,
+    inkWorkflows,
+    prompts,
+    runWithInlineAuth,
+    previewDraft,
+    startNewLogworkWizard
+  } = ctx;
+
+  const saveCurrentDraft = useCallback(async () => {
+    if (wizard?.target === JIRA_TARGET) {
+      setActivePanel({
+        kind: 'logwork',
+        title: 'Save Draft',
+        text: 'Saved drafts are only supported for Resource Optimiser logwork in this version.'
+      });
+      return null;
+    }
+
+    if (!wizard?.selectedDate || !wizard?.selectedProject || !wizard?.tasks?.length) {
+      setActivePanel({
+        kind: 'logwork',
+        title: 'Save Draft',
+        text: 'Add at least one task before saving a draft.'
+      });
+      return null;
+    }
+
+    try {
+      const saved = await saveManualDraft({
+        id: wizard.activeDraftId,
+        cwd,
+        date: wizard.selectedDate,
+        project: wizard.selectedProject,
+        tasks: wizard.tasks,
+        latestPreviewStatus: wizard.preview?.status
+      }, { cwd });
+      setWizard((current) => ({
+        ...current,
+        activeDraftId: saved.id
+      }));
+      setActivePanel({
+        kind: 'success',
+        title: 'Draft Saved',
+        text: [
+          `Saved ${saved.tasks.length} task${saved.tasks.length === 1 ? '' : 's'} locally.`,
+          formatManualDraftLabel(saved),
+          '',
+          'Continue editing, press empty Enter to apply, or type /drafts.'
+        ].join('\n')
+      });
+      return saved;
+    } catch (error) {
+      setActivePanel({
+        kind: 'error',
+        title: 'Save Draft Error',
+        text: error.message
+      });
+      return null;
+    }
+  }, [cwd, wizard]);
+
+  const openDraftPicker = useCallback(async (source = 'editor') => {
+    setLoading('Loading saved drafts...');
+    try {
+      const drafts = await loadManualDrafts({ cwd });
+      if (!drafts.length) {
+        setActivePanel({
+          kind: 'logwork',
+          title: 'Saved Drafts',
+          text: 'No saved drafts found.'
+        });
+        return;
+      }
+      setWizard((current) => ({
+        ...current,
+        step: 'select_draft',
+        drafts,
+        draftIndex: 0,
+        draftSource: source
+      }));
+      setActivePanel({
+        kind: 'logwork',
+        title: 'Saved Drafts',
+        text: 'Enter resumes · d deletes · Esc returns.'
+      });
+    } catch (error) {
+      setActivePanel({
+        kind: 'error',
+        title: 'Draft Error',
+        text: error.message
+      });
+    } finally {
+      setLoading('');
+    }
+  }, [cwd]);
+
+  const resumeManualDraft = useCallback(async (draft) => {
+    setLoading('Resuming saved draft...');
+    try {
+      const weekly = await runWithInlineAuth(() => inkWorkflows.queryLogwork({
+        period: 'this_week',
+        cwd,
+        includeEntries: false
+      }));
+      const dateOptions = buildWeekDateOptions(weekly);
+      const projectsResult = await runWithInlineAuth(() => inkWorkflows.listLogworkProjects({ cwd }));
+      const projectOptions = buildProjectOptions({
+        projectsResult,
+        weekly,
+        date: draft.date
+      });
+      const selectedProject = projectOptions.find((project) => sameProjectIdentity(project, draft.project)) || draft.project;
+      const nextWizard = {
+        step: 'edit_tasks',
+        target: RO_TARGET,
+        weekly,
+        dateOptions,
+        dateIndex: Math.max(0, dateOptions.findIndex((option) => option.date === draft.date)),
+        projectsResult,
+        projectOptions,
+        projectIndex: Math.max(0, projectOptions.findIndex((project) => sameProjectIdentity(project, selectedProject))),
+        selectedDate: draft.date,
+        selectedProject,
+        tasks: draft.tasks,
+        preview: null,
+        activeDraftId: draft.id
+      };
+      sessionRef.current.logworkDraft = {
+        target: RO_TARGET,
+        date: draft.date,
+        project: selectedProject,
+        tasks: draft.tasks,
+        preview: null
+      };
+      clearSessionPreviews(sessionRef.current);
+      sessionRef.current.activeTarget = RO_TARGET;
+      await previewDraft(nextWizard);
+    } catch (error) {
+      setActivePanel({
+        kind: 'error',
+        title: 'Resume Draft Error',
+        text: error.message
+      });
+    } finally {
+      setLoading('');
+    }
+  }, [cwd, inkWorkflows, previewDraft, runWithInlineAuth]);
+
+  const deleteSavedDraft = useCallback(async (draft) => {
+    const ok = await prompts.confirm(`Delete saved draft "${formatManualDraftLabel(draft)}"?`, false);
+    if (!ok) {
+      return;
+    }
+    await deleteManualDraft(draft.id);
+    const drafts = await loadManualDrafts({ cwd });
+    setWizard((current) => ({
+      ...current,
+      drafts,
+      draftIndex: 0
+    }));
+    setActivePanel({
+      kind: 'success',
+      title: 'Draft Deleted',
+      text: drafts.length ? 'Draft deleted. Choose another saved draft or start new.' : 'Draft deleted. No saved drafts remain.'
+    });
+  }, [cwd, prompts]);
+
+  const returnFromDraftPicker = useCallback(() => {
+    if (wizard?.draftSource === 'start') {
+      startNewLogworkWizard(RO_TARGET);
+      return;
+    }
+    setWizard((current) => ({
+      ...current,
+      step: 'edit_tasks',
+      draftSource: undefined
+    }));
+    const draft = {
+      target: wizard?.target || RO_TARGET,
+      date: wizard?.selectedDate,
+      project: wizard?.selectedProject,
+      tasks: wizard?.tasks || [],
+      preview: wizard?.preview
+    };
+    setActivePanel({
+      kind: 'logwork',
+      title: wizard?.preview ? 'Logwork Preview' : 'Logwork Draft',
+      text: [
+        formatDraftPreview(draft),
+        '',
+        'Type / for task commands. Empty Enter applies when ready.'
+      ].join('\n')
+    });
+  }, [startNewLogworkWizard, wizard]);
+
+  return {
+    saveCurrentDraft,
+    openDraftPicker,
+    resumeManualDraft,
+    deleteSavedDraft,
+    returnFromDraftPicker
+  };
+}

package/lib/manual-ink-interaction.mjs

@@ -0,0 +1,306 @@
+// The bottom interaction area of the Ink app: the auth prompt, a confirm dialog,
+// the active wizard picker, or the command input. A plain render function (not a
+// component) so the element tree matches the single-component layout.
+import React from 'react';
+import { toggleTaskSelection } from './manual-logwork-wizard.mjs';
+import { AUTH_TARGETS, LOGWORK_TARGETS, RO_TARGET } from './manual-targets.mjs';
+import {
+  CommandInput,
+  ConfirmDialog,
+  DatePicker,
+  DraftPicker,
+  McpClientPicker,
+  ProjectPicker,
+  TargetPicker,
+  TaskEditPicker,
+  TaskRemovePicker
+} from './manual-ink-ui.mjs';
+import { AuthPrompt } from './manual-ink-auth.mjs';
+import { RECONCILIATION_PERIOD_OPTIONS } from './manual-ink-session.mjs';
+
+const h = React.createElement;
+
+export function renderManualInteraction({
+  authPrompt,
+  authActive,
+  pendingConfirm,
+  wizard,
+  inputValue,
+  selectedIndex,
+  setInputValue,
+  setSelectedIndex,
+  setAuthPrompt,
+  setWizard,
+  setActivePanel,
+  resolveAuthPrompt,
+  rejectAuthPrompt,
+  resolveConfirm,
+  exit,
+  executeCommand,
+  submitInput,
+  startLogworkWizard,
+  startNewLogworkWizard,
+  selectWizardDate,
+  selectWizardProject,
+  cancelMcpClientPicker,
+  cancelCurrentLogwork,
+  restoreTaskEditorPanel,
+  resumeManualDraft,
+  deleteSavedDraft,
+  returnFromDraftPicker,
+  confirmRemoveTasks,
+  cancelRemoveTasks,
+  selectTaskForEdit
+}) {
+  return authPrompt
+    ? h(AuthPrompt, {
+      prompt: authPrompt,
+      inputValue,
+      onInputChange(value) {
+        setInputValue(value);
+      },
+      onPromptChange(nextPrompt) {
+        setAuthPrompt(nextPrompt);
+      },
+      onResolve: resolveAuthPrompt,
+      onReject: rejectAuthPrompt
+    })
+    : authActive
+      ? h(AuthPrompt, {
+        prompt: { step: 'working' },
+        inputValue,
+        onInputChange(value) {
+          setInputValue(value);
+        },
+        onPromptChange(nextPrompt) {
+          setAuthPrompt(nextPrompt);
+        },
+        onResolve: resolveAuthPrompt,
+        onReject: rejectAuthPrompt
+      })
+    : pendingConfirm
+    ? h(ConfirmDialog, {
+      message: pendingConfirm.message,
+      initialValue: pendingConfirm.initialValue,
+      onResolve: resolveConfirm
+    })
+    : wizard?.step === 'select_logwork_target'
+      ? h(TargetPicker, {
+        title: 'Pick logwork target',
+        targets: LOGWORK_TARGETS,
+        selectedIndex: wizard.targetIndex || 0,
+        onChange(index) {
+          setWizard((current) => ({
+            ...current,
+            targetIndex: index
+          }));
+        },
+        onSelect(target) {
+          startLogworkWizard(target.key);
+        },
+        onCancel() {
+          setWizard(null);
+          setActivePanel({
+            kind: 'idle',
+            title: 'Ready',
+            text: 'Type / for commands.'
+          });
+        }
+      })
+    : wizard?.step === 'select_auth_target'
+      ? h(TargetPicker, {
+        title: 'Pick auth target',
+        targets: AUTH_TARGETS,
+        selectedIndex: wizard.targetIndex || 0,
+        onChange(index) {
+          setWizard((current) => ({
+            ...current,
+            targetIndex: index
+          }));
+        },
+        onSelect(target) {
+          executeCommand({
+            type: 'auth',
+            target: target.key
+          });
+        },
+        onCancel() {
+          setWizard(null);
+          setActivePanel({
+            kind: 'idle',
+            title: 'Ready',
+            text: 'Type / for commands.'
+          });
+        }
+      })
+    : wizard?.step === 'select_reconciliation_period'
+      ? h(TargetPicker, {
+        title: 'Pick reconciliation period',
+        targets: RECONCILIATION_PERIOD_OPTIONS,
+        selectedIndex: wizard.periodIndex || 0,
+        onChange(index) {
+          setWizard((current) => ({
+            ...current,
+            periodIndex: index
+          }));
+        },
+        onSelect(period) {
+          executeCommand({
+            type: 'reconcile',
+            period: period.key
+          });
+        },
+        onCancel() {
+          setWizard(null);
+          setActivePanel({
+            kind: 'idle',
+            title: 'Ready',
+            text: 'Type / for commands.'
+          });
+        }
+      })
+    : wizard?.step === 'select_draft'
+      ? h(DraftPicker, {
+        drafts: wizard.drafts || [],
+        selectedIndex: wizard.draftIndex || 0,
+        includeStartNew: wizard.draftSource === 'start',
+        onChange(index) {
+          setWizard((current) => ({
+            ...current,
+            draftIndex: index
+          }));
+        },
+        onResume(draft) {
+          resumeManualDraft(draft);
+        },
+        onDelete(draft) {
+          deleteSavedDraft(draft);
+        },
+        onStartNew() {
+          startNewLogworkWizard(RO_TARGET);
+        },
+        onCancel() {
+          returnFromDraftPicker();
+        }
+      })
+      : wizard?.step === 'select_date'
+      ? h(DatePicker, {
+        options: wizard.dateOptions,
+        selectedIndex: wizard.dateIndex,
+        onChange(index) {
+          setWizard((current) => ({
+            ...current,
+            dateIndex: index
+          }));
+        },
+        onSelect(option) {
+          selectWizardDate(option);
+        }
+      })
+      : wizard?.step === 'select_project'
+        ? h(ProjectPicker, {
+          options: wizard.projectOptions,
+          selectedIndex: wizard.projectIndex,
+          onChange(index) {
+            setWizard((current) => ({
+              ...current,
+              projectIndex: index
+            }));
+          },
+          onSelect(project) {
+            selectWizardProject(project);
+          }
+        })
+        : wizard?.step === 'select_mcp_client'
+          ? h(McpClientPicker, {
+            selectedIndex: wizard.mcpClientIndex || 0,
+            onChange(index) {
+              setWizard((current) => ({
+                ...current,
+                mcpClientIndex: index
+              }));
+            },
+            onSelect(client) {
+              executeCommand({
+                type: 'mcp',
+                client: client.key
+              });
+            },
+            onCancel() {
+              cancelMcpClientPicker();
+            }
+          })
+        : wizard?.step === 'remove_tasks'
+          ? h(TaskRemovePicker, {
+            tasks: wizard.tasks,
+            selectedIndex: wizard.removeIndex || 0,
+            selectedIndexes: wizard.removeSelectedIndexes || [],
+            onChange(index) {
+              setWizard((current) => ({
+                ...current,
+                removeIndex: index
+              }));
+            },
+            onToggle(index) {
+              setWizard((current) => ({
+                ...current,
+                removeSelectedIndexes: toggleTaskSelection(current.removeSelectedIndexes || [], index)
+              }));
+            },
+            onSubmit(indexes) {
+              confirmRemoveTasks(indexes);
+            },
+            onCancel() {
+              cancelRemoveTasks();
+            }
+          })
+        : wizard?.step === 'edit_task_select'
+          ? h(TaskEditPicker, {
+            tasks: wizard.tasks,
+            selectedIndex: wizard.editIndex || 0,
+            onChange(index) {
+              setWizard((current) => ({
+                ...current,
+                editIndex: index
+              }));
+            },
+            onSelect(index) {
+              selectTaskForEdit(index);
+            },
+            onCancel() {
+              setWizard((current) => ({
+                ...current,
+                step: 'edit_tasks'
+              }));
+              restoreTaskEditorPanel();
+            }
+          })
+        : h(CommandInput, {
+          value: inputValue,
+          onChange(value) {
+            setInputValue(value);
+            setSelectedIndex(0);
+          },
+          onSubmit: submitInput,
+          selectedIndex,
+          setSelectedIndex,
+          mode: wizard?.step === 'edit_tasks' ? 'task' : wizard?.step === 'edit_task_replace' ? 'task-edit' : 'command',
+          onEscape() {
+            if (!wizard) {
+              exit();
+              return;
+            }
+            if (wizard?.step === 'edit_tasks') {
+              cancelCurrentLogwork();
+              return;
+            }
+            if (wizard?.step === 'edit_task_replace') {
+              setWizard((current) => ({
+                ...current,
+                step: 'edit_tasks'
+              }));
+              restoreTaskEditorPanel();
+            }
+          }
+        });
+}

package/lib/manual-ink-session.mjs

@@ -0,0 +1,41 @@
+// Manual session preview bookkeeping shared by the Ink app and its action hooks.
+import { JIRA_TARGET, RO_TARGET } from './manual-targets.mjs';
+
+export const RECONCILIATION_PERIOD_OPTIONS = [
+  { key: 'today', label: 'Today', description: 'Compare today' },
+  { key: 'yesterday', label: 'Yesterday', description: 'Compare yesterday' },
+  { key: 'this_week', label: 'This week', description: 'Compare Monday through Sunday' },
+  { key: 'last_week', label: 'Last week', description: 'Compare the previous week' },
+  { key: 'this_month', label: 'This month', description: 'Compare the current month' },
+  { key: 'last_month', label: 'Last month', description: 'Compare the previous month' }
+];
+
+export function setSessionPreview(session, target, preview) {
+  session.activeTarget = target;
+  session.previews = {
+    ...(session.previews || {}),
+    [target]: preview
+  };
+}
+
+export function clearSessionPreviews(session) {
+  session.previews = {
+    [RO_TARGET]: null,
+    [JIRA_TARGET]: null
+  };
+}
+
+export function sessionPreview(session, target) {
+  return session.previews?.[target] || null;
+}
+
+export function hasSessionPreview(session) {
+  return Boolean(session.previews?.[RO_TARGET] || session.previews?.[JIRA_TARGET]);
+}
+
+export function activeSessionPreview(session) {
+  if (session.activeTarget === JIRA_TARGET) {
+    return sessionPreview(session, JIRA_TARGET);
+  }
+  return sessionPreview(session, RO_TARGET);
+}