logwork-cli 1.1.1 → 1.3.0

package/lib/ui.mjs

@@ -1,8 +1,23 @@
-import { cancel, confirm, isCancel, note, outro, select, text } from '@clack/prompts';
+import * as clackPrompts from '@clack/prompts';
 import { CONFIG } from './config.mjs';
+import { formatSuggestionReason, orderProjectsForPicker } from './repo-project-suggestions.mjs';
 
-export async function chooseProject(projects, daySummaries) {
-  const options = projects.map((project, index) => {
+// Every prompt function takes an optional `{ prompts }` (default: @clack/prompts)
+// so tests can answer prompts without a terminal.
+
+export async function chooseProject(projects, daySummaries, { prompts = clackPrompts } = {}) {
+  const options = projectSelectOptions(projects, daySummaries);
+
+  const projectMemberId = handleCancel(await prompts.select({
+    message: 'Chọn project cần log work:',
+    options
+  }), prompts);
+
+  return projects.find((project) => project.projectMemberId === projectMemberId);
+}
+
+export function projectSelectOptions(projects, daySummaries) {
+  return 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`;
@@ -12,88 +27,130 @@ export async function chooseProject(projects, daySummaries) {
       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
+export const SKIP_REPO_PROJECT = '__skip__';
+
+// Options for "which RO project does this repo belong to?": suggested projects
+// first (reason as hint), then every other member project, then skip. Values
+// are option keys; resolve them with the returned items.
+export function repoProjectSelectOptions(suggestions = [], candidates = [], { skipLabel = 'Skip for now' } = {}) {
+  const items = orderProjectsForPicker(candidates, suggestions);
+  const options = items.map((item, index) => ({
+    value: `project:${index}`,
+    label: item.project.projectName || `project member ${item.project.projectMemberId}`,
+    ...(item.suggestion ? { hint: formatSuggestionReason(item.suggestion) } : {})
   }));
+  options.push({ value: SKIP_REPO_PROJECT, label: skipLabel });
+  return {
+    items,
+    options,
+    initialValue: options[0].value
+  };
+}
 
-  return projects.find((project) => project.projectMemberId === projectMemberId);
+export function repoProjectFromOption(items, value) {
+  const match = /^project:(\d+)$/.exec(String(value || ''));
+  return match ? items[Number(match[1])]?.project || null : null;
+}
+
+// Asks which project a repo belongs to. Returns the chosen project, or null
+// when the user skips (Escape / Ctrl+C also skip).
+export async function chooseRepoProject({ repoName, suggestions = [], candidates = [] }, { prompts = clackPrompts } = {}) {
+  const { items, options, initialValue } = repoProjectSelectOptions(suggestions, candidates);
+  if (!items.length) {
+    return null;
+  }
+  const value = await prompts.select({
+    message: `Which RO project does ${repoName} belong to?`,
+    options,
+    initialValue
+  });
+  if (prompts.isCancel(value)) {
+    return null;
+  }
+  return repoProjectFromOption(items, value);
 }
 
-export async function chooseTask(tasks) {
-  const taskId = handleCancel(await select({
+export async function chooseTask(tasks, { prompts = clackPrompts } = {}) {
+  const taskId = handleCancel(await prompts.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
-    }))
-  }));
+    options: taskSelectOptions(tasks)
+  }), prompts);
 
   return tasks.find((task) => task.taskId === taskId);
 }
 
-export async function chooseMessageSource(defaultMessage) {
-  const source = handleCancel(await select({
+export function taskSelectOptions(tasks) {
+  return tasks.map((task) => ({
+    value: task.taskId,
+    label: `${task.name} (${task.typeOfWork})`,
+    hint: task.description
+  }));
+}
+
+export async function chooseMessageSource(defaultMessage, { prompts = clackPrompts } = {}) {
+  const source = handleCancel(await prompts.select({
     message: 'Task message:',
     options: [
       { value: 'git', label: 'Use git commit message' },
       { value: 'custom', label: 'Custom' }
     ],
     initialValue: 'git'
-  }));
+  }), prompts);
 
   const initialValue = source === 'git' ? defaultMessage : '';
-  const value = handleCancel(await text({
+  const value = handleCancel(await prompts.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;
-    }
-  }));
+    validate: validateTaskMessage
+  }), prompts);
 
   return value.trim();
 }
 
-export async function askHours(defaultHours = CONFIG.defaultHours) {
-  const value = handleCancel(await text({
+export function validateTaskMessage(input) {
+  if (!input || input.trim() === '') {
+    return 'Vui lòng nhập nội dung công việc.';
+  }
+  return undefined;
+}
+
+export async function askHours(defaultHours = CONFIG.defaultHours, { prompts = clackPrompts } = {}) {
+  const value = handleCancel(await prompts.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 validateHours(input);
     }
-  }));
+  }), prompts);
 
   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}?`,
+export function validateHours(input, hourStep = CONFIG.hourStep) {
+  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 / hourStep)) {
+    return `Số giờ phải chia hết cho ${hourStep}.`;
+  }
+
+  return undefined;
+}
+
+export async function confirmSubmit(payloadPreview, { prompts = clackPrompts } = {}) {
+  const ok = handleCancel(await prompts.confirm({
+    message: formatSubmitConfirmation(payloadPreview),
     initialValue: true
-  }));
+  }), prompts);
 
   if (!ok) {
     throw new Error('User declined final submit.');
@@ -102,16 +159,24 @@ export async function confirmSubmit(payloadPreview) {
   return true;
 }
 
-export function showSuccess(message) {
-  outro(message);
+export function formatSubmitConfirmation(payloadPreview) {
+  const task = truncate(payloadPreview.taskName, 80);
+  const description = payloadPreview.description
+    ? ` | "${truncate(payloadPreview.description, 120)}"`
+    : '';
+  return `Log ${payloadPreview.hours}h to ${payloadPreview.projectName} with task "${task}"${description}?`;
+}
+
+export function showSuccess(message, { prompts = clackPrompts } = {}) {
+  prompts.outro(message);
 }
 
-export function showError(error) {
-  cancel(error?.message || String(error));
+export function showError(error, { prompts = clackPrompts } = {}) {
+  prompts.cancel(error?.message || String(error));
 }
 
-export function handleCancel(value) {
-  if (isCancel(value)) {
+export function handleCancel(value, prompts = clackPrompts) {
+  if (prompts.isCancel(value)) {
     throw new Error('Cancelled.');
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logwork-cli",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Log work to Resource Optimiser and Jira from the terminal, an MCP server for AI IDEs, and a terminal UI.",
   "license": "UNLICENSED",
   "type": "module",
@@ -58,9 +58,11 @@
     "audit:prod": "npm audit --omit=dev --audit-level=moderate",
     "pack:check": "npm pack --dry-run",
     "release:doctor": "node bin/logwork.mjs release doctor --full",
-    "release:check": "npm test && npm run audit:prod && npm run pack:check && git diff --check",
-    "test:windows-credential": "node --test --test-name-pattern=\"Windows Credential Manager stores, reads, and deletes a test credential\" test/credential-store.test.mjs",
-    "test": "node --test"
+    "lint": "eslint .",
+    "release:check": "npm run lint && npm test && npm run audit:prod && npm run pack:check && git diff --check",
+    "test:windows-credential": "node --import ./test/helpers/setup.mjs --test --test-name-pattern=\"Windows Credential Manager stores, reads, and deletes a test credential\" test/credential-store.test.mjs",
+    "test": "node --import ./test/helpers/setup.mjs --test \"test/*.test.mjs\"",
+    "test:coverage": "node --import ./test/helpers/setup.mjs --test --experimental-test-coverage --test-coverage-include=\"bin/**\" --test-coverage-include=\"commands/**\" --test-coverage-include=\"lib/**\" --test-coverage-lines=78 --test-coverage-branches=75 --test-coverage-functions=85 \"test/*.test.mjs\""
   },
   "dependencies": {
     "@clack/prompts": "^1.5.0",
@@ -71,5 +73,10 @@
     "ink-text-input": "^6.0.0",
     "react": "^19.2.7",
     "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.5",
+    "eslint": "^9.39.5",
+    "globals": "^17.14.0"
   }
 }

package/skills/logwork/SKILL.md

@@ -10,19 +10,25 @@ Goal: every logged line is backed by real work (the user's commits or what the u
 ## Steps
 
 1. **Find the gaps.** Call `get_logwork` for the period. A day/project still needs time when booked > logged. Skip days that are already full.
-2. **Collect the evidence.** Call `draft_from_commits` with the same period and `repos` set to every repo the user worked in (the open workspace folders; ask the user for others). It groups the user's commits per day by repo, ticket and kind of work, suggests a worklog task per group, and splits each day's remaining RO hours across the groups. Treat its hours as a starting point, not a fact.
+2. **Collect the evidence.** Call `draft_from_commits` with the same period and `repos` set to every repo the user worked in (the open workspace folders; ask the user for others). It groups the user's commits per day by repo, ticket and kind of work, suggests a worklog task per group, picks each group's RO project (a `map_project` mapping whose `repos` holds the repo, else ticket/keyword mappings and that day's bookings), and splits each project's remaining RO hours across its groups. It returns `draftText` and `projectOverrides` (preview entry id → `projectMemberId`). Treat its hours as a starting point, not a fact.
 3. **Check the worklog tasks.** For each project involved, call `list_tasks(projectId)`. Keep the suggested task when it exists in that catalog; otherwise pick the catalog task whose description matches the work.
 4. **Write the descriptions.** One line per piece of work: what was done and the outcome, with ticket keys, in English, under about 200 characters, no `|`. Rewrite vague commit subjects ("wip", "fix", "update"); use `get_jira_issue` to read the ticket when the subject alone is unclear.
 5. **Set the hours.**
-   - Stay within the remaining booked hours per day and project unless the user says otherwise. The draft splits the day's total; use each day's `remainingByProject` to move hours to the project the work belongs to.
+   - Stay within the remaining booked hours per day and project unless the user says otherwise. The draft already gives each project at most its own remaining hours; lines without a project share the room of booked projects no other line claimed. A project with no room left gets 0h, and the summary says so.
    - If `draft_from_commits` returns `authRequired`, call `login` first; do not guess hours without RO.
    - Use 0.5h steps.
    - Do not log weekends or days without a booking unless the user asks.
    - Work without commits (meetings, reviews, support) only comes from the user; ask, then log it as `Other Activities` or `Code Review & Refactoring`.
-6. **Resolve projects.** Ticket prefixes and mappings pick the project. If a line stays unresolved, ask the user and offer `map_project` so it is automatic next time.
+6. **Resolve projects.** The draft's `projectOverrides` already name the project of every resolved line. For each repo in `unmappedRepos` (lines with no project):
+   - Take the top entry of `repoSuggestions[repo]` (ranked by ticket history, repo/remote name and single booked project; `reasons` say why).
+   - Ask one short question per repo, by project name: "Is `<repo name>` part of **<projectName>**? (<first reason>)". With no suggestion, ask which project it belongs to and offer names from `projectCandidates`.
+   - On a yes (or the user's own pick), call `map_project` with `projectName` (or that suggestion's `projectMemberId`), `repos: [repo]` and `confirm: true`. Never ask the user for ids.
+   - Then run `draft_from_commits` again so those lines get their project and hours.
+   A line `log_work` still cannot resolve: ask the user and add its id to `projectOverrides`.
 7. **Get approval, then write.**
    - Show the final block to the user.
-   - On approval, call `log_work(text)` and show its preview summary.
+   - On approval, call `log_work(text, projectOverrides)` and show its preview summary. Pass `projectOverrides` from the draft unchanged when `draftText` is unchanged. Entry ids are `<date>-<NN>` with NN counting lines through the whole text, so if you add, remove or reorder lines, renumber the overrides to match.
+   - If the preview flags `possibleDuplicate` entries, show the warnings. They match an existing RO entry (or an earlier line) on date, worklog task, hours and description. Usually drop those lines and preview again. Pass `allowDuplicates: true` on the confirm call only when the user says it is really new work.
    - Then call `log_work(batchId, confirm: true)`.
    - If the user also logs Jira, do the same with `log_jira_work`. Jira needs exactly one issue key per line.