logwork-cli 0.0.0-stage → 1.1.0

package/commands/auth.mjs

@@ -0,0 +1,227 @@
+import {
+  getStoredAuthStatus,
+  loginResourceOptimiser,
+  logoutResourceOptimiser
+} from '../lib/auth.mjs';
+import { authenticateWithApiSession } from '../lib/api-auth.mjs';
+import { createAuthDiagnosticsRecorder } from '../lib/auth-diagnostics.mjs';
+import { credentialStoreLabel } from '../lib/credential-store.mjs';
+import {
+  getStoredJiraStatus,
+  loginJira,
+  logoutJira,
+  safeJiraAuthError
+} from '../lib/jira-auth.mjs';
+
+// `logwork login|logout|status [ro|jira]`. Resource Optimiser is the default
+// target. Secrets are only ever typed in this terminal and stored in the OS
+// credential store; they are never accepted as arguments.
+
+export async function runLogin(argv = []) {
+  const { target, args } = splitTarget(argv);
+  if (wantsHelp(args)) {
+    console.log(formatAuthHelp());
+    return 0;
+  }
+  if (target === 'jira') {
+    const result = await runJiraLoginCommand(parseJiraLoginArgs(args));
+    return result.ok ? 0 : 1;
+  }
+  parseLoginArgs(args);
+  const result = await runLoginCommand();
+  return result.ok ? 0 : 1;
+}
+
+export async function runLogout(argv = []) {
+  const { target, args } = splitTarget(argv);
+  if (wantsHelp(args)) {
+    console.log(formatAuthHelp());
+    return 0;
+  }
+  assertNoArgs(args, 'logout');
+  const result = target === 'jira' ? await logoutJira() : await logoutResourceOptimiser();
+  console.log(result.summary);
+  return 0;
+}
+
+export async function runStatus(argv = []) {
+  if (wantsHelp(argv)) {
+    console.log(formatAuthHelp());
+    return 0;
+  }
+  const { target, args } = splitTarget(argv);
+  assertNoArgs(args, 'status');
+  const targets = argv.length ? [target] : ['ro', 'jira'];
+  let authenticated = true;
+  for (const item of targets) {
+    const result = item === 'jira' ? await getStoredJiraStatus() : await getStoredAuthStatus();
+    console.log(`${item === 'jira' ? 'Jira' : 'Resource Optimiser'}: ${result.summary}`);
+    if (item === 'ro' && !result.authenticated) {
+      authenticated = false;
+    }
+  }
+  return authenticated ? 0 : 1;
+}
+
+export function formatAuthHelp() {
+  const storeLabel = credentialStoreLabel();
+  return `Usage:
+  logwork login [ro|jira] [--base-url <url>]
+  logwork logout [ro|jira]
+  logwork status [ro|jira]
+
+Targets:
+  ro    Resource Optimiser (default). Email, password and 2FA are asked in this terminal.
+  jira  Jira Personal Access Token, pasted in this terminal.
+
+Sessions are stored in ${storeLabel}, never in files or command arguments.
+
+Options:
+  --base-url <url>  Jira base URL for \`login jira\`. Defaults to https://jira-vnv.vinova.sg`;
+}
+
+function splitTarget(argv = []) {
+  const [first, ...rest] = argv;
+  if (first === 'ro' || first === 'jira') {
+    return { target: first, args: rest };
+  }
+  return { target: 'ro', args: argv };
+}
+
+function wantsHelp(args) {
+  return args.includes('--help') || args.includes('-h');
+}
+
+function assertNoArgs(args, command) {
+  if (args.length) {
+    throw new Error(`Unknown ${command} option: ${args[0]}`);
+  }
+}
+
+export async function runLoginCommand({
+  login = loginResourceOptimiser,
+  createRecorder = createAuthDiagnosticsRecorder,
+  stdout = console.log,
+  stderr = console.error
+} = {}) {
+  stdout('Starting Resource Optimiser API auth. Secrets are requested in this terminal and are not stored.');
+  const diagnosticsRecorder = createRecorder();
+
+  try {
+    const result = await login({
+      authenticator: (options) => authenticateWithApiSession({
+        ...options,
+        diagnosticsRecorder
+      })
+    });
+    stdout(result.summary);
+    return {
+      ok: true,
+      result
+    };
+  } catch (error) {
+    stderr(error.message);
+    try {
+      const written = await diagnosticsRecorder.writeFailure(error);
+      stderr(`Auth failed. Sanitized diagnostics saved to ${written.path}. Attempt: ${written.attemptId}`);
+    } catch (writeError) {
+      stderr(`Auth failed. Unable to write sanitized diagnostics: ${writeError.message}`);
+    }
+    return {
+      ok: false,
+      error
+    };
+  }
+}
+
+export function parseLoginArgs(args = []) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--api-mode') {
+      continue;
+    }
+
+    if (arg === '--browser' || arg.startsWith('--browser=')) {
+      throw new Error('Browser auth has been removed. Run `logwork login` for API-only auth.');
+    }
+
+    if (arg === '--browser-mode') {
+      throw new Error('Browser auth has been removed. Run `logwork login` for API-only auth.');
+    }
+
+    if (arg === 'record') {
+      throw new Error('Auth recording has been removed because auth is API-only.');
+    }
+
+    if (arg === '--help' || arg === '-h') {
+      continue;
+    }
+
+    throw new Error(`Unknown auth login option: ${arg}`);
+  }
+
+  return { mode: 'api' };
+}
+
+export async function runJiraLoginCommand({
+  baseUrl,
+  login = loginJira,
+  stdout = console.log,
+  stderr = console.error
+} = {}) {
+  stdout('Starting Jira PAT auth. Paste the token in this terminal; it is stored only in the OS credential store.');
+
+  try {
+    const result = await login({
+      ...(baseUrl ? { baseUrl } : {})
+    });
+    stdout(result.summary);
+    return {
+      ok: true,
+      result
+    };
+  } catch (error) {
+    const safeError = safeJiraAuthError(error);
+    stderr(safeError.message);
+    return {
+      ok: false,
+      error: safeError
+    };
+  }
+}
+
+export function parseJiraLoginArgs(args = []) {
+  const options = {};
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--help' || arg === '-h') {
+      continue;
+    }
+
+    if (arg === '--base-url') {
+      const value = args[index + 1];
+      if (!value || value.startsWith('--')) {
+        throw new Error('--base-url requires a value.');
+      }
+      options.baseUrl = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--base-url=')) {
+      const value = arg.slice('--base-url='.length);
+      if (!value) {
+        throw new Error('--base-url requires a value.');
+      }
+      options.baseUrl = value;
+      continue;
+    }
+
+    throw new Error(`Unknown jira login option: ${arg}`);
+  }
+
+  return options;
+}

package/commands/commits.mjs

@@ -0,0 +1,82 @@
+import { draftLogworkFromCommits } from '../lib/commit-workflow.mjs';
+import { normalizeReconciliationPeriod } from '../lib/reconciliation-workflow.mjs';
+
+// `logwork commits [period] [--repo path]... [--author x] [--no-bookings] [--json]`:
+// turn your git commits into a logwork draft. Read-only.
+export function parseCommitsArgs(args = []) {
+  const options = { period: 'today', repos: [], author: undefined, useBookings: true, json: false, help: false };
+  const positional = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--no-bookings') {
+      options.useBookings = false;
+    } else if (arg === '--repo' || arg === '--author') {
+      const value = args[index + 1];
+      if (!value || value.startsWith('--')) {
+        throw new Error(`${arg} requires a value.`);
+      }
+      if (arg === '--repo') {
+        options.repos.push(value);
+      } else {
+        options.author = value;
+      }
+      index += 1;
+    } else if (arg.startsWith('--repo=')) {
+      options.repos.push(arg.slice('--repo='.length));
+    } else if (arg.startsWith('--author=')) {
+      options.author = arg.slice('--author='.length);
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown commits option: ${arg}`);
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (positional.length > 1) {
+    throw new Error('commits accepts exactly one preset period.');
+  }
+  if (positional[0]) {
+    options.period = normalizeReconciliationPeriod(positional[0]);
+  }
+  return options;
+}
+
+export async function run(args = [], { draft = draftLogworkFromCommits, print = console.log } = {}) {
+  const options = parseCommitsArgs(args);
+  if (options.help) {
+    print(formatCommitsHelp());
+    return 0;
+  }
+  const result = await draft({
+    period: options.period,
+    repos: options.repos,
+    author: options.author,
+    useBookings: options.useBookings
+  });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return 0;
+}
+
+export function formatCommitsHelp() {
+  return `Usage:
+  logwork commits [today|yesterday|this-week|last-week|this-month|last-month]
+                  [--repo <path>]... [--author <email>] [--no-bookings] [--json]
+
+Reads your commits (all branches, your git user.email) from each repo (default:
+the current directory) and drafts logwork lines:
+  +<hours> <worklog task> | <description>
+
+- Commits are grouped per day by repo, ticket key and kind of work.
+- The kind of work picks the worklog task: feat -> Feature Development,
+  fix -> Bug Fix, refactor/perf/review -> Code Review & Refactoring,
+  test -> Testing Activities, ci/build/release -> Deployment & Release,
+  docs/design -> Requirements & Design, chore -> Other Activities.
+- Hours split the day's RO remaining time (booked - logged) by how much work
+  each group holds. With --no-bookings or without login, a weekday is 8h.
+
+Nothing is written. Review the draft, then paste it into /logwork or give it
+to your AI agent (log_work).`;
+}

package/commands/delete.mjs

@@ -0,0 +1,69 @@
+import { confirm, isCancel } from '@clack/prompts';
+import { parseRoDeleteArgs } from '../lib/ro-delete-args.mjs';
+import {
+  applyRoLogworkDelete,
+  previewRoLogworkDelete
+} from '../lib/ro-delete-workflow.mjs';
+
+export async function runRoDeleteCommand(args = [], {
+  preview = previewRoLogworkDelete,
+  apply = applyRoLogworkDelete,
+  promptConfirm = defaultConfirm,
+  isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY),
+  print = console.log
+} = {}) {
+  const options = parseRoDeleteArgs(args);
+  if (options.help) {
+    print(formatRoDeleteHelp());
+    return null;
+  }
+
+  if (options.json && !options.yes) {
+    throw new Error('--json requires --yes so stdout remains valid JSON.');
+  }
+
+  const deletePreview = await preview({ logworkId: options.logworkId });
+  if (!options.json) {
+    print(deletePreview.summary);
+  }
+
+  let approved = options.yes;
+  if (!approved) {
+    if (!isTTY) {
+      throw new Error('Interactive confirmation is unavailable. Re-run with --yes.');
+    }
+    approved = await promptConfirm(`Delete RO logwork entry ${deletePreview.logworkId}?`);
+  }
+  if (!approved) {
+    print('RO logwork delete cancelled.');
+    return null;
+  }
+
+  const result = await apply({
+    preview: deletePreview,
+    confirm: true
+  });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return result;
+}
+
+export function formatRoDeleteHelp() {
+  return `Usage:
+  logwork delete <logwork-id> [--yes] [--json]
+
+Soft-deletes one Resource Optimiser logwork entry (submitted or approved only).
+The command previews the entry, checks for concurrent changes, then calls DELETE /logwork/entries/:id.
+
+Options:
+  -y, --yes             Delete without interactive confirmation
+  --json                Print structured JSON; requires --yes
+  -h, --help            Show this help`;
+}
+
+async function defaultConfirm(message) {
+  const result = await confirm({
+    message,
+    initialValue: false
+  });
+  return !isCancel(result) && result === true;
+}

package/commands/doctor.mjs

@@ -0,0 +1,24 @@
+import { generateDiagnosticsReport } from '../lib/diagnostics.mjs';
+
+export async function run(args = []) {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    return;
+  }
+  if (args.length) {
+    throw new Error(`Unknown doctor option: ${args[0]}`);
+  }
+
+  const result = await generateDiagnosticsReport();
+  console.log(result.summary);
+  console.log('Send this sanitized file to the developer. Do not send raw curl logs, cookies, passwords, OTPs, or tokens.');
+}
+
+function printHelp() {
+  console.log(`Usage:
+  logwork doctor
+
+Checks your setup and writes a sanitized support report under ~/.logwork-cli/diagnostics.
+The report redacts tokens, cookies, passwords, OTPs, auth codes, and raw HTML.
+`);
+}

package/commands/edit.mjs

@@ -0,0 +1,88 @@
+import { confirm, isCancel } from '@clack/prompts';
+import { parseRoEditArgs } from '../lib/ro-edit-args.mjs';
+import {
+  applyRoLogworkEdit,
+  previewRoLogworkEdit
+} from '../lib/ro-edit-workflow.mjs';
+
+export async function runRoEditCommand(args = [], {
+  preview = previewRoLogworkEdit,
+  apply = applyRoLogworkEdit,
+  promptConfirm = defaultConfirm,
+  isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY),
+  print = console.log
+} = {}) {
+  const options = parseRoEditArgs(args);
+  if (options.help) {
+    print(formatRoEditHelp());
+    return null;
+  }
+
+  if (options.json && !options.yes) {
+    throw new Error('--json requires --yes so stdout remains valid JSON.');
+  }
+
+  const editPreview = await preview({
+    logworkId: options.logworkId,
+    hours: options.hours,
+    taskName: options.taskName,
+    description: options.description,
+    typeOfWork: options.typeOfWork
+  });
+  if (!options.json) {
+    print(editPreview.summary);
+  }
+
+  let approved = options.yes;
+  if (!approved) {
+    if (!isTTY) {
+      throw new Error('Interactive confirmation is unavailable. Re-run with --yes.');
+    }
+    approved = await promptConfirm(`Apply RO logwork edit ${editPreview.previewId}?`);
+  }
+  if (!approved) {
+    print('RO logwork edit cancelled.');
+    return null;
+  }
+
+  const result = await apply({
+    preview: editPreview,
+    confirm: true
+  });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return result;
+}
+
+export function formatRoEditHelp() {
+  return `Usage:
+  logwork edit <id> [--hours <h>] [--task <task>] [--desc <text>] [--type <type>] [--yes] [--json]
+
+Changes one Resource Optimiser entry. Project and date are preserved. Get the id
+from \`logwork query\`.
+
+RO has no staff edit API, so apply replaces the entry: it creates the corrected
+entry, then deletes the original (the new entry gets a new id and is approved
+immediately). If the delete fails, the new entry is rolled back. Only submitted
+or approved entries can be edited; rejected entries are fixed with resubmit.
+
+Options:
+  --hours <h>      New hours (alias: --logtimes)
+  --task <task>    New worklog task from the project catalog, or #<id> (alias: --task-name)
+  --desc <text>    New description: what you did (alias: --description)
+  --type <type>    New type of work: create, correct, improve, other
+                   (follows the new task's catalog type when the task changes)
+  -y, --yes        Apply without the confirmation prompt
+  --json           Print the result as JSON (requires --yes)
+  -h, --help       Show this help
+
+Example:
+  logwork edit 304032 --task "Bug Fix" --desc "Fix date picker timezone (SAP-42)"`;
+}
+
+async function defaultConfirm(message) {
+  const result = await confirm({
+    message,
+    initialValue: false
+  });
+  return !isCancel(result) && result === true;
+}

package/commands/history.mjs

@@ -0,0 +1,62 @@
+import { queryApplyLedger } from '../lib/apply-ledger.mjs';
+
+export function parseHistoryArgs(args = []) {
+  const options = {
+    target: undefined,
+    limit: 20,
+    json: false
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--target') {
+      options.target = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--limit') {
+      options.limit = Number(args[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      return { help: true };
+    }
+    throw new Error(`Unknown history option: ${arg}`);
+  }
+
+  return options;
+}
+
+export async function runHistoryCommand(args = [], {
+  query = queryApplyLedger,
+  print = console.log
+} = {}) {
+  const options = parseHistoryArgs(args);
+  if (options.help) {
+    printHistoryHelp(print);
+    return null;
+  }
+
+  const result = await query({
+    target: options.target,
+    limit: options.limit
+  });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return result;
+}
+
+function printHistoryHelp(print = console.log) {
+  print(`Usage:
+  logwork history [--target ro|jira|both] [--limit <count>] [--json]
+
+Shows the local apply result ledger. Target both means entries applied from a combined Both flow.`);
+}
+
+async function main() {
+  await runHistoryCommand(process.argv.slice(2));
+}

package/commands/query.mjs

@@ -0,0 +1,52 @@
+import { queryLogwork } from '../lib/query-workflow.mjs';
+import { normalizeReconciliationPeriod } from '../lib/reconciliation-workflow.mjs';
+
+// `logwork query [period] [--json]`: booked vs logged Resource Optimiser hours,
+// with each entry's id, worklog task, description and status.
+export function parseQueryArgs(args = []) {
+  const options = { period: 'today', json: false, help: false };
+  const positional = [];
+  for (const arg of args) {
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+    if (arg.startsWith('-')) {
+      throw new Error(`Unknown query option: ${arg}`);
+    }
+    positional.push(arg);
+  }
+  if (positional.length > 1) {
+    throw new Error('Query accepts exactly one preset period.');
+  }
+  if (positional[0]) {
+    options.period = normalizeReconciliationPeriod(positional[0]);
+  }
+  return options;
+}
+
+export async function run(args = [], {
+  query = queryLogwork,
+  print = console.log
+} = {}) {
+  const options = parseQueryArgs(args);
+  if (options.help) {
+    print(formatQueryHelp());
+    return 0;
+  }
+  const result = await query({ period: options.period, includeEntries: true });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return 0;
+}
+
+export function formatQueryHelp() {
+  return `Usage:
+  logwork query [today|yesterday|this-week|last-week|this-month|last-month] [--json]
+
+Shows booked vs logged Resource Optimiser hours per day and project, with each
+entry's id (use it with \`logwork edit\` / \`logwork delete\`). Defaults to today.`;
+}