logwork-cli 0.0.0-stage → 1.0.0

package/lib/ro-resubmit-workflow.mjs

@@ -0,0 +1,134 @@
+import { ApiError, resubmitLogworkEntry } from './api.mjs';
+import { createResourceOptimiserSession } from './query-workflow.mjs';
+import { createF03LogworkReader } from './ro-entry-reader.mjs';
+
+export async function previewRoLogworkResubmit({
+  logworkId,
+  hours,
+  typeOfWork,
+  noteToPm,
+  description,
+  fetchLogwork
+}) {
+  const reader = fetchLogwork || createF03LogworkReader();
+  const current = await reader(assertIdentifier(logworkId, 'logworkId'));
+  if (String(current.status || '').toLowerCase() !== 'rejected') {
+    throw new Error('Only rejected RO logwork entries can be resubmitted through this flow.');
+  }
+
+  const effortHours = hours === undefined ? current.hours : Number(hours);
+  if (!Number.isFinite(effortHours) || effortHours <= 0) {
+    throw new Error('hours must be a positive number.');
+  }
+
+  const previewId = `resubmit_${current.id}_${effortHours}`;
+  const preview = {
+    previewId,
+    status: 'ready',
+    logworkId: current.id,
+    original: current,
+    updated: {
+      hours: effortHours,
+      typeOfWork: typeOfWork || current.typeOfWork || 'other',
+      noteToPm: noteToPm ?? current.noteToPm ?? '',
+      description: description ?? current.description ?? ''
+    },
+    originalFingerprint: createLogworkRevisionFingerprint(current)
+  };
+  preview.summary = [
+    'RO logwork resubmit preview:',
+    `- Entry: ${current.id}`,
+    `- Hours: ${current.hours} -> ${effortHours}`,
+    `- Status: rejected -> approved (after resubmit)`
+  ].join('\n');
+  return preview;
+}
+
+export async function applyRoLogworkResubmit({
+  preview,
+  confirm,
+  fetchLogwork,
+  submitResubmit
+}) {
+  if (confirm !== true) {
+    throw new Error('Resubmit requires confirm: true.');
+  }
+  if (!preview || preview.status !== 'ready') {
+    throw new Error('A valid resubmit preview is required (resubmit_entry without confirm).');
+  }
+
+  const reader = fetchLogwork || createF03LogworkReader();
+  const writer = submitResubmit || createResubmitWriter();
+  const current = await reader(preview.logworkId);
+  if (createLogworkRevisionFingerprint(current) !== preview.originalFingerprint) {
+    throw new Error('RO logwork changed after preview. Preview the resubmit again before applying.');
+  }
+
+  const result = await writer({
+    logworkId: preview.logworkId,
+    effortHours: preview.updated.hours,
+    typeOfWork: preview.updated.typeOfWork,
+    noteToPm: preview.updated.noteToPm,
+    description: preview.updated.description
+  });
+
+  if (result?.dryRun) {
+    return {
+      status: 'dry_run',
+      dryRun: true,
+      logworkId: preview.logworkId,
+      result,
+      summary: `Dry run: RO logwork ${preview.logworkId} was not resubmitted.`
+    };
+  }
+
+  return {
+    status: 'resubmitted',
+    logworkId: preview.logworkId,
+    result,
+    summary: `Resubmitted RO logwork ${preview.logworkId} with ${preview.updated.hours}h.`
+  };
+}
+
+function createResubmitWriter() {
+  const session = createResourceOptimiserSession();
+  return async (payload) => {
+    const { token } = await session.get();
+    try {
+      return await resubmitLogworkEntry(token, payload.logworkId, {
+        effortHours: payload.effortHours,
+        typeOfWork: payload.typeOfWork,
+        noteToPm: payload.noteToPm,
+        description: payload.description
+      });
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 401) {
+        throw error;
+      }
+      const refreshed = await session.get({ forceLogin: true });
+      return resubmitLogworkEntry(refreshed.token, payload.logworkId, {
+        effortHours: payload.effortHours,
+        typeOfWork: payload.typeOfWork,
+        noteToPm: payload.noteToPm,
+        description: payload.description
+      });
+    }
+  };
+}
+
+function assertIdentifier(value, label) {
+  const text = String(value ?? '').trim();
+  if (!text) {
+    throw new Error(`${label} is required.`);
+  }
+  return text;
+}
+
+function createLogworkRevisionFingerprint(logwork) {
+  return JSON.stringify({
+    id: logwork.id,
+    hours: logwork.hours,
+    status: logwork.status,
+    taskName: logwork.taskName
+  });
+}

package/lib/terminal-auth-prompts.mjs

@@ -0,0 +1,120 @@
+import { isCancel, password, select, text } from '@clack/prompts';
+import { createAuthRequiredError } from './auth-errors.mjs';
+import { createCredentialEmailStorage } from './credential-store.mjs';
+
+export function createTerminalCredentialProvider({
+  emailStorage = createCredentialEmailStorage(),
+  stdin = process.stdin,
+  stdout = process.stdout
+} = {}) {
+  return {
+    async requestCredentials() {
+      ensureInteractive(stdin, stdout);
+      const rememberedEmail = await emailStorage.get().catch(() => null);
+      const email = handleCancel(await text({
+        message: 'Resource Optimiser email:',
+        placeholder: 'name@example.com',
+        initialValue: rememberedEmail || '',
+        validate(value) {
+          if (!String(value || '').trim()) {
+            return 'Email is required.';
+          }
+          return undefined;
+        }
+      })).trim();
+
+      const secret = handleCancel(await password({
+        message: 'Resource Optimiser password:',
+        validate(value) {
+          if (!String(value || '')) {
+            return 'Password is required.';
+          }
+          return undefined;
+        }
+      }));
+
+      await emailStorage.set(email).catch(() => {});
+      return {
+        email,
+        password: secret
+      };
+    },
+
+    async requestPasswordUpdate() {
+      ensureInteractive(stdin, stdout);
+      const newPassword = handleCancel(await password({
+        message: 'New Resource Optimiser password:',
+        validate(value) {
+          if (!String(value || '')) {
+            return 'New password is required.';
+          }
+          return undefined;
+        }
+      }));
+      const confirmPassword = handleCancel(await password({
+        message: 'Confirm new Resource Optimiser password:',
+        validate(value) {
+          if (!String(value || '')) {
+            return 'Password confirmation is required.';
+          }
+          if (value !== newPassword) {
+            return 'Passwords do not match.';
+          }
+          return undefined;
+        }
+      }));
+
+      return {
+        newPassword,
+        confirmPassword
+      };
+    },
+
+    async requestDeviceSelection(devices) {
+      ensureInteractive(stdin, stdout);
+      if (!Array.isArray(devices) || devices.length === 0) {
+        return null;
+      }
+      if (devices.length === 1) {
+        return devices[0];
+      }
+
+      const selected = handleCancel(await select({
+        message: 'Choose 2FA device:',
+        options: devices.map((device, index) => ({
+          value: String(index),
+          label: device.label || `Device ${index + 1}`
+        }))
+      }));
+
+      return devices[Number(selected)];
+    },
+
+    async requestOtp() {
+      ensureInteractive(stdin, stdout);
+      return handleCancel(await password({
+        message: '2FA code:',
+        validate(value) {
+          if (!String(value || '').trim()) {
+            return '2FA code is required.';
+          }
+          return undefined;
+        }
+      })).trim();
+    }
+  };
+}
+
+function ensureInteractive(stdin, stdout) {
+  if (!stdin?.isTTY || !stdout?.isTTY) {
+    throw createAuthRequiredError();
+  }
+}
+
+function handleCancel(value) {
+  if (isCancel(value)) {
+    throw new Error('User cancelled Resource Optimiser authentication.');
+  }
+
+  return value;
+}

package/lib/ui.mjs

@@ -0,0 +1,133 @@
+import { cancel, confirm, isCancel, note, outro, select, text } from '@clack/prompts';
+import { CONFIG } from './config.mjs';
+
+export async function chooseProject(projects, daySummaries) {
+  const options = projects.map((project, index) => {
+    const summary = daySummaries[index];
+    const logged = summary?.ok ? `${formatHours(summary.totalHours)}h` : `${formatHours(project.loggedHours)}h`;
+    const booked = `${formatHours(project.assignedHours)}h`;
+
+    return {
+      value: project.projectMemberId,
+      label: `${project.projectName} - ${booked}/day (${project.workloadPercent}% assigned) · ${logged} logged today`
+    };
+  });
+
+  const projectMemberId = handleCancel(await select({
+    message: 'Chọn project cần log work:',
+    options
+  }));
+
+  return projects.find((project) => project.projectMemberId === projectMemberId);
+}
+
+export async function chooseTask(tasks) {
+  const taskId = handleCancel(await select({
+    message: 'Chọn loại công việc:',
+    options: tasks.map((task) => ({
+      value: task.taskId,
+      label: `${task.name} (${task.typeOfWork})`,
+      hint: task.description
+    }))
+  }));
+
+  return tasks.find((task) => task.taskId === taskId);
+}
+
+export async function chooseMessageSource(defaultMessage) {
+  const source = handleCancel(await select({
+    message: 'Task message:',
+    options: [
+      { value: 'git', label: 'Use git commit message' },
+      { value: 'custom', label: 'Custom' }
+    ],
+    initialValue: 'git'
+  }));
+
+  const initialValue = source === 'git' ? defaultMessage : '';
+  const value = handleCancel(await text({
+    message: 'Nội dung công việc:',
+    placeholder: 'Fix login flow',
+    initialValue,
+    validate(input) {
+      if (!input || input.trim() === '') {
+        return 'Vui lòng nhập nội dung công việc.';
+      }
+      return undefined;
+    }
+  }));
+
+  return value.trim();
+}
+
+export async function askHours(defaultHours = CONFIG.defaultHours) {
+  const value = handleCancel(await text({
+    message: 'Số giờ log:',
+    placeholder: String(defaultHours),
+    initialValue: String(defaultHours),
+    validate(input) {
+      const numeric = Number(input);
+
+      if (!Number.isFinite(numeric)) {
+        return 'Số giờ phải là số.';
+      }
+      if (numeric <= 0) {
+        return 'Số giờ phải lớn hơn 0.';
+      }
+      if (!Number.isInteger(numeric / CONFIG.hourStep)) {
+        return `Số giờ phải chia hết cho ${CONFIG.hourStep}.`;
+      }
+
+      return undefined;
+    }
+  }));
+
+  return Number(value);
+}
+
+export async function confirmSubmit(payloadPreview) {
+  const task = truncate(payloadPreview.taskName, 80);
+  const description = payloadPreview.description
+    ? ` | "${truncate(payloadPreview.description, 120)}"`
+    : '';
+  const ok = handleCancel(await confirm({
+    message: `Log ${payloadPreview.hours}h to ${payloadPreview.projectName} with task "${task}"${description}?`,
+    initialValue: true
+  }));
+
+  if (!ok) {
+    throw new Error('User declined final submit.');
+  }
+
+  return true;
+}
+
+export function showSuccess(message) {
+  outro(message);
+}
+
+export function showError(error) {
+  cancel(error?.message || String(error));
+}
+
+export function handleCancel(value) {
+  if (isCancel(value)) {
+    throw new Error('Cancelled.');
+  }
+
+  return value;
+}
+
+function formatHours(value) {
+  const number = Number(value || 0);
+  return Number.isInteger(number) ? String(number) : String(number.toFixed(1)).replace(/\.0$/, '');
+}
+
+function truncate(value, maxLength) {
+  const textValue = String(value);
+  if (textValue.length <= maxLength) {
+    return textValue;
+  }
+
+  return `${textValue.slice(0, maxLength - 1)}…`;
+}