logwork-cli 1.2.0 → 1.3.1

package/docs/recipes.md

@@ -41,16 +41,29 @@ The assistant uses `list_projects` and `list_tasks`, writes `+2 <task> | <descri
 
 ## Log From Commits Into The Right Projects
 
-Tell logwork which RO project each repo belongs to, once:
+Each repo needs its RO project once. Just run the draft:
+
+```bash
+logwork commits yesterday
+```
+
+For a repo with no project yet, it asks in place:
 
 ```text
-logwork
-/map --repo ~/code/portal 5234
+Which RO project does portal-web belong to?
+› Customer Portal · ticket CP-12 was logged to this project on 2026-11-03
+  GKE Fair Chem System (FCS)
+  Managed Hosting
+  Skip for now
 ```
 
-or ask your assistant: `Map the repo /Users/me/code/portal to my Portal project` (it calls `list_projects`, then `map_project` with `repos` after you approve).
+The likely project is preselected. Press Enter to save it as a repo mapping; the draft is then redone with that repo's lines on the project. `Skip for now` asks again next time; `--no-prompt` never asks.
+
+Other ways to map a repo, all without ids:
+- Terminal UI: `/map --repo` (this folder) or `/map --repo ~/code/portal` opens the same picker; `/map --repo ~/code/portal Customer Portal` maps by name (a unique part of the name is enough).
+- Assistant: `draft_from_commits` returns `repoSuggestions`, so the assistant asks "Is portal-web part of Customer Portal?" and calls `map_project` with `projectName` and `repos` after you say yes.
 
-Then `logwork commits yesterday` (or the assistant's `draft_from_commits`) puts that repo's commits on project 5234. The hours come from what is still free on that project: booked minus logged. If the project is already full, its lines get 0h and the summary says so. Repos without a mapping fall back to ticket/keyword mappings and that day's bookings, and are listed at the end so you can map them.
+Mapped repos put their commits on that project. The hours come from what is still free on that project: booked minus logged. If the project is already full, its lines get 0h and the summary says so. Repos without a mapping fall back to ticket/keyword mappings and that day's bookings.
 
 The assistant passes the draft's `projectOverrides` to `log_work` with the same text, so each line is logged to the project the draft chose.
 

package/docs/security.md

@@ -113,11 +113,30 @@ The runtime and local state live in `~/.logwork-cli` (`%USERPROFILE%\.logwork-cl
 | `update-state.json` | Update check cache: package name, latest SemVer, and check timestamp. Expires after 24 hours and contains no npm credentials. |
 | `reminder.json`, `reminder-state.json` | Reminder config: enabled state, local time, target, weekdays and optional git repo paths for the commit summary. Last-run state: sanitized timestamps and status summaries. |
 | `runtime.json` | The Node path and version `logwork setup` ran with, its install time and the package version. |
+| `bin/logwork-launch` (macOS) | The launcher MCP configs and the reminder run. A `sh` script with the runtime path and the recorded Node path, nothing else. |
 | `diagnostics/` | Sanitized diagnostics reports from `logwork doctor`. |
 
 The apply ledger stores the target, flow target, batch ID, timestamp, workspace path, entry metadata, and submitted/failed/blocked status. It does not store credentials, cookies, or raw API responses, and token-like error text is redacted before writing.
 
-The macOS launch agent and Windows scheduled task contain only fixed Node and script paths (`bin/logwork.mjs reminder run`). They never contain RO tokens, Jira PATs, passwords, or API responses.
+The macOS launch agent runs `bin/logwork-launch reminder run`, and the Windows scheduled task runs a fixed `node.exe` with `bin/logwork.mjs reminder run`. They never contain RO tokens, Jira PATs, passwords, or API responses.
+
+## MCP Client Configs
+
+`logwork setup` and `logwork mcp install` edit the MCP config of the clients they find, after asking (or with `--yes`):
+
+| Client | File or command |
+| --- | --- |
+| Claude Code | `claude mcp remove` / `claude mcp add --scope user` (or `~/.claude.json` without the CLI) |
+| Cursor | `~/.cursor/mcp.json` |
+| Codex | `~/.codex/config.toml` |
+| VS Code | user `mcp.json` (`~/Library/Application Support/Code/User`, `%APPDATA%\Code\User`) |
+| Google Antigravity | `~/.gemini/antigravity/mcp_config.json` |
+
+- Only the `logwork` server entry is written, plus removal of an old `logwork-helper` entry (and, in Claude Code, a stale project-scope `logwork` entry). Other servers and settings are kept.
+- The entry holds only `command` and `args` (the launcher or `node.exe`, the runtime path and `mcp`). No token, PAT, password, cookie or email is ever written to an MCP config.
+- Before changing a file, it is copied to `<file>.logwork-backup-<YYYYMMDDHHmmss>` in the same folder, with the same permissions as the original. The new file is written atomically. Backups are never deleted automatically; remove them when you no longer need them. A backup can contain other servers' settings (for example API keys in their `env`), exactly as the original file does.
+- A file that does not parse cleanly (comments, trailing commas, unusual TOML) is never written; the snippet is printed instead.
+- `logwork mcp install --dry-run` and `logwork mcp status` only read.
 
 ## Safety Model
 

package/examples/mcp/antigravity.mcp_config.json

@@ -1,8 +1,8 @@
 {
   "mcpServers": {
     "logwork": {
-      "command": "<absolute path to node>",
-      "args": ["<home>/.logwork-cli/bin/logwork.mjs", "mcp"]
+      "command": "<home>/.logwork-cli/bin/logwork-launch",
+      "args": ["mcp"]
     }
   }
 }

package/examples/mcp/codex.config.toml

@@ -1,5 +1,5 @@
 [mcp_servers.logwork]
-command = "<absolute path to node>"
-args = ["<home>/.logwork-cli/bin/logwork.mjs", "mcp"]
+command = "<home>/.logwork-cli/bin/logwork-launch"
+args = ["mcp"]
 startup_timeout_sec = 20
 tool_timeout_sec = 120

package/examples/mcp/copilot.mcp.json

@@ -2,8 +2,8 @@
   "servers": {
     "logwork": {
       "type": "stdio",
-      "command": "<absolute path to node>",
-      "args": ["<home>/.logwork-cli/bin/logwork.mjs", "mcp"]
+      "command": "<home>/.logwork-cli/bin/logwork-launch",
+      "args": ["mcp"]
     }
   }
 }

package/lib/commit-workflow.mjs

@@ -6,7 +6,16 @@ import { CONFIG } from './config.mjs';
 import { findRepoMapping, loadLocalConfig } from './logwork-config.mjs';
 import { projectIdentityKey, sameProjectIdentity } from './project-identity.mjs';
 import { resolveEntryProject } from './project-resolver.mjs';
-import { normalizeQueryRange, queryLogwork } from './query-workflow.mjs';
+import {
+  createMembershipProjectsFetcher,
+  normalizeQueryRange,
+  queryLogwork
+} from './query-workflow.mjs';
+import {
+  bookedProjectsByDateFromQuery,
+  historyFromQueryResult,
+  suggestRepoProjects
+} from './repo-project-suggestions.mjs';
 import { addLocalDays, todayLocalDateISO } from './util.mjs';
 
 // Builds a logwork draft from the user's own git commits:
@@ -18,7 +27,10 @@ import { addLocalDays, todayLocalDateISO } from './util.mjs';
 //   -> each project's remaining hours (RO booked - logged) are split across its
 //      groups by how much work each group holds; unresolved groups share the
 //      room of booked projects no group claimed (without RO: a standard day)
-//   -> a "+<hours> <worklog task> | <description>" block for log_work.
+//   -> a "+<hours> <worklog task> | <description>" block for log_work
+//   -> for each repo whose lines got no project, ranked project suggestions
+//      (ticket history, repo/remote name, single booked project) so the user
+//      can confirm one and map the repo once.
 // Nothing is written anywhere; the agent shows the draft, the user edits and
 // approves it, then log_work previews and applies it as usual.
 
@@ -31,6 +43,7 @@ const CONVENTIONAL_RE = /^(\w+)(?:\([^)]*\))?!?:\s*/;
 const FIELD = '\x1f';
 const RECORD = '\x1e';
 const MAX_DESCRIPTION_LENGTH = 240;
+const SUGGESTION_HISTORY_DAYS = 30;
 
 // Default RO catalog task per kind of work. These are the shared default task
 // names; a project with its own catalog may need a different name (list_tasks).
@@ -415,7 +428,11 @@ export async function draftLogworkFromCommits({
   runGit = runGitCommand,
   queryRo = queryLogwork,
   loadConfig = loadLocalConfig,
-  platform = process.platform
+  platform = process.platform,
+  suggestProjects = true,
+  fetchProjects,
+  historyDays = SUGGESTION_HISTORY_DAYS,
+  today = todayLocalDateISO()
 } = {}) {
   const range = from || to ? normalizeQueryRange({ from, to }) : normalizeQueryRange({ period });
   const repoPaths = [...new Set((repos?.length ? repos : [cwd]).map((repo) => resolve(cwd, expandHome(String(repo)))))];
@@ -538,6 +555,25 @@ export async function draftLogworkFromCommits({
     .filter((group) => !group.project)
     .map((group) => group.repoPath))];
 
+  // Suggestions need RO (candidates and history), so they are skipped when the
+  // bookings were not read.
+  const suggestions = unmappedRepos.length && bookings && suggestProjects
+    ? await buildRepoSuggestions({
+      unmappedRepos,
+      days,
+      bookings,
+      queryRo,
+      // Memberships come from the same source as the bookings: a caller that
+      // injects queryRo (tests, other workflows) gets none unless it injects
+      // fetchProjects too, so it never reaches the real RO.
+      fetchProjects: fetchProjects || (queryRo === queryLogwork ? createMembershipProjectsFetcher() : async () => []),
+      runGit,
+      cwd,
+      today,
+      historyDays
+    })
+    : { repoSuggestions: {}, projectCandidates: [] };
+
   const result = {
     status: !commits.length ? 'no_commits' : (draftText ? 'draft' : 'no_hours'),
     range,
@@ -548,7 +584,9 @@ export async function draftLogworkFromCommits({
     days,
     draftText,
     projectOverrides,
-    unmappedRepos
+    unmappedRepos,
+    repoSuggestions: suggestions.repoSuggestions,
+    projectCandidates: suggestions.projectCandidates
   };
   result.summary = formatCommitDraftSummary(result);
   return result;
@@ -600,11 +638,128 @@ export function formatCommitDraftSummary(result) {
     }
   }
   if (result.unmappedRepos?.length) {
-    lines.push('', `No project for some lines from: ${result.unmappedRepos.join(', ')}. Ask the user which RO project each repo belongs to and offer map_project with repos so later drafts know it.`);
+    lines.push('', 'No project for the lines of these repos. Confirm each repo\'s RO project once (logwork commits asks in a terminal; /map --repo in the terminal UI; agents call map_project with projectName and repos):');
+    for (const repo of result.unmappedRepos) {
+      const top = result.repoSuggestions?.[repo]?.[0];
+      lines.push(top
+        ? `- ${repo}: likely ${projectLabel(top)} (${top.reasons.join('; ')})`
+        : `- ${repo}: no suggestion; ask which project it belongs to`);
+    }
   }
   return lines.join('\n');
 }
 
+// Ranked project suggestions per unmapped repo. RO history and memberships
+// are read once per draft and are best effort: an auth error still reaches the
+// caller (authRequired), any other error only drops that evidence.
+async function buildRepoSuggestions({ unmappedRepos, days, bookings, queryRo, fetchProjects, runGit, cwd, today, historyDays }) {
+  const historyResult = await bestEffort(() => queryRo({
+    from: addLocalDays(today, -historyDays),
+    to: addLocalDays(today, 1),
+    includeEntries: true,
+    cwd
+  }));
+  const memberships = await bestEffort(fetchProjects);
+  const projectCandidates = mergeCandidates([
+    ...[...bookings.values()].flatMap((day) => day.projects.filter((project) => project.bookedHours > 0)),
+    ...(Array.isArray(memberships) ? memberships : [])
+  ]);
+  const history = historyFromQueryResult(historyResult);
+  const bookedProjectsByDate = {};
+  for (const [date, day] of bookings) {
+    bookedProjectsByDate[date] = day.projects.filter((project) => project.bookedHours > 0);
+  }
+
+  const repoSuggestions = {};
+  for (const repo of unmappedRepos) {
+    const repoGroups = days.flatMap((day) => day.groups
+      .filter((group) => group.repoPath === repo && !group.project)
+      .map((group) => ({ ...group, date: day.date })));
+    repoSuggestions[repo] = suggestRepoProjects({
+      repoPath: repo,
+      repoGroups,
+      candidates: projectCandidates,
+      history,
+      remoteUrl: await readRemoteUrl(repo, runGit),
+      bookedProjectsByDate
+    });
+  }
+  return { repoSuggestions, projectCandidates };
+}
+
+// Suggestions for one repo outside a draft (the terminal UI /map picker): the
+// last historyDays of the repo's commits, RO entries and bookings, ranked
+// against the given member projects.
+export async function suggestProjectsForRepo({
+  repo,
+  projects = [],
+  author,
+  cwd = process.cwd(),
+  runGit = runGitCommand,
+  queryRo = queryLogwork,
+  historyDays = SUGGESTION_HISTORY_DAYS,
+  today = todayLocalDateISO()
+} = {}) {
+  const repoPath = resolve(cwd, expandHome(String(repo || '.')));
+  const root = await resolveGitRepoRoot(repoPath, runGit);
+  const from = addLocalDays(today, -historyDays);
+  const to = addLocalDays(today, 1);
+  const commits = await readRepoCommits({ repo: root, from, to, author, runGit })
+    .then((result) => result.commits)
+    .catch(() => []);
+  const repoGroups = [...new Set(commits.map((commit) => commit.date))]
+    .flatMap((date) => groupCommits(commits.filter((commit) => commit.date === date)).map((group) => ({ ...group, date })));
+  const historyResult = await bestEffort(() => queryRo({ from, to, includeEntries: true, cwd }));
+  const candidates = mergeCandidates(projects);
+  return {
+    repoRoot: root,
+    candidates,
+    suggestions: suggestRepoProjects({
+      repoPath: root,
+      repoGroups,
+      candidates,
+      history: historyFromQueryResult(historyResult),
+      remoteUrl: await readRemoteUrl(root, runGit),
+      bookedProjectsByDate: bookedProjectsByDateFromQuery(historyResult)
+    })
+  };
+}
+
+export async function readRemoteUrl(repo, runGit = runGitCommand) {
+  try {
+    return String(await runGit(repo, ['remote', 'get-url', 'origin'])).trim();
+  } catch {
+    return '';
+  }
+}
+
+async function bestEffort(action) {
+  try {
+    return await action();
+  } catch (error) {
+    if (isAuthRequiredError(error)) {
+      throw error;
+    }
+    return null;
+  }
+}
+
+function mergeCandidates(projects) {
+  const results = [];
+  for (const project of projects) {
+    if (!project || !(project.projectName || hasValue(project.projectMemberId))) {
+      continue;
+    }
+    const known = results.findIndex((candidate) => sameProjectIdentity(candidate, project));
+    if (known < 0) {
+      results.push(projectRef(project));
+    } else {
+      results[known] = { ...projectRef(project), ...results[known] };
+    }
+  }
+  return results;
+}
+
 function projectRef(project = {}) {
   return {
     projectName: project.projectName || '',

package/lib/diagnostics.mjs

@@ -10,7 +10,9 @@ import { getStoredAuthStatus } from './auth.mjs';
 import { redactText } from './auth-redaction.mjs';
 import { authDebugLogPath, sanitizeDiagnosticValue } from './auth-diagnostics.mjs';
 import { configPath, loadLocalConfig } from './logwork-config.mjs';
-import { formatNodePathIssue, inspectNodePath, loadRuntimeInfo } from './node-runtime.mjs';
+import { checkLaunchCommand, formatLaunchCheckIssue, resolveLaunchCommand } from './launcher.mjs';
+import { createMcpInstallContext, inspectMcpClients } from './mcp-install.mjs';
+import { formatNodePathIssue, inspectNodePath, inspectScheduledCommand, loadRuntimeInfo } from './node-runtime.mjs';
 import { helperHome, manualDraftsPath, runtimeInfoPath, userConfigPath } from './paths.mjs';
 import { readReminderSchedulerNodePath } from './reminder-scheduler.mjs';
 
@@ -37,6 +39,7 @@ export async function generateDiagnosticsReport({
   authStatusFn = getStoredAuthStatus,
   mcpSmokeFn = runMcpSmoke,
   nodeRuntimeFn = collectNodeRuntimeCheck,
+  mcpClientsFn = collectMcpClientCheck,
   readFileFn = readFile,
   statFn = stat,
   writeFileFn = writeFile,
@@ -50,7 +53,12 @@ export async function generateDiagnosticsReport({
   const configSnapshot = await safeCollect('config snapshot', () => collectConfigSnapshot({ cwd, includeMappingDetails }));
   const mcpSmoke = await safeCollect('mcp smoke', () => mcpSmokeFn({ cwd }));
   const nodeRuntime = await safeCollect('node runtime', () => nodeRuntimeFn());
-  const nodeIssues = Array.isArray(nodeRuntime?.issues) ? nodeRuntime.issues : [];
+  const mcpClients = await safeCollect('mcp clients', () => mcpClientsFn());
+  const runtimeIssues = Array.isArray(nodeRuntime?.issues) ? nodeRuntime.issues : [];
+  const mcpIssues = (Array.isArray(mcpClients) ? mcpClients : [])
+    .filter((client) => client.status === 'stale' || client.legacy || client.localScopes)
+    .map((client) => `MCP: ${formatMcpClientCheck(client)}. Fix: run \`logwork mcp install\`.`);
+  const nodeIssues = [...runtimeIssues, ...mcpIssues];
   const authDebug = await readSanitizedAuthDebug({ readFileFn });
 
   sections.push(formatSection('logwork-cli Diagnostics', [
@@ -72,13 +80,26 @@ export async function generateDiagnosticsReport({
     ? formatObjectLines(nodeRuntime)
     : [
       `runtimeFile: ${nodeRuntime.runtimeFile}`,
+      ...(nodeRuntime.launchCommand ? [
+        `launchCommand: ${nodeRuntime.launchCommand}`,
+        `launchStatus: ${nodeRuntime.launchStatus}`,
+        `launchNode: ${nodeRuntime.launchNode || 'unknown'}`,
+        `launchVersion: ${nodeRuntime.launchVersion || 'unknown'}`
+      ] : []),
       `recordedNode: ${nodeRuntime.recordedNode || 'none (run logwork setup)'}${nodeRuntime.recordedVersion ? ` (${nodeRuntime.recordedVersion})` : ''}`,
-      `recordedNodeStatus: ${nodeRuntime.recordedStatus}`,
+      `recordedNodeStatus: ${nodeRuntime.recordedStatus}${nodeRuntime.recordedNote ? ` (${nodeRuntime.recordedNote})` : ''}`,
       `reminderNode: ${nodeRuntime.reminderNode || 'none (no reminder schedule)'}`,
       `reminderNodeStatus: ${nodeRuntime.reminderStatus}`,
-      ...(nodeIssues.length ? nodeIssues.map((issue) => `warning: ${issue}`) : ['warnings: none'])
+      ...(runtimeIssues.length ? runtimeIssues.map((issue) => `warning: ${issue}`) : ['warnings: none'])
     ]));
 
+  sections.push(formatSection('MCP Clients', Array.isArray(mcpClients)
+    ? [
+      ...(mcpClients.length ? mcpClients.map(formatMcpClientCheck) : ['none detected']),
+      ...mcpIssues.map((issue) => `warning: ${issue}`)
+    ]
+    : formatObjectLines(mcpClients)));
+
   sections.push(formatSection('Commands', commandChecks.map((entry) => `${entry.command}: ${entry.available ? 'found' : 'missing'}${entry.path ? ` (${entry.path})` : ''}`)));
   sections.push(formatSection('Files', fileChecks.map((entry) => formatFileCheck(entry))));
   sections.push(formatSection('Config Snapshot', formatObjectLines(configSnapshot)));
@@ -101,36 +122,78 @@ export async function generateDiagnosticsReport({
   };
 }
 
-// Compares the node recorded by `logwork setup` (runtime.json) and the node in
-// the installed reminder schedule with the node running now. Read-only.
+// Checks the launch command IDE configs and the reminder run (it must exist
+// and start a usable Node), the node recorded by `logwork setup`
+// (runtime.json) and the command in the installed reminder schedule.
+// Read-only: it only runs the launch command with --version.
 export async function collectNodeRuntimeCheck({
+  launch = resolveLaunchCommand(),
   loadRuntime = loadRuntimeInfo,
   readSchedulerNodePath = readReminderSchedulerNodePath,
-  inspect = inspectNodePath
+  inspect = inspectNodePath,
+  inspectScheduled = (path) => inspectScheduledCommand(path, { launch }),
+  checkLaunch = () => checkLaunchCommand(launch)
 } = {}) {
   const runtime = await loadRuntime().catch(() => null);
   const reminderNode = await readSchedulerNodePath().catch(() => null);
+  const launchCheck = await checkLaunch().catch((error) => ({ status: 'failed', command: launch.command, kind: launch.kind, detail: error.message }));
   const recorded = runtime?.nodePath
     ? await inspect(runtime.nodePath)
     : { status: 'unknown' };
   const reminder = reminderNode
-    ? await inspect(reminderNode)
+    ? await inspectScheduled(reminderNode)
     : { status: 'unknown' };
+  // With the launcher, a gone or switched recorded node is not fatal: the
+  // launcher falls back to another Node 22+.
+  const launcherCovers = launch.kind === 'launcher' && launchCheck?.status === 'ok';
+  const recordedNote = launcherCovers && (recorded.status === 'missing' || recorded.status === 'stale')
+    ? `the launcher uses ${launchCheck.node || 'another Node'}; run \`logwork setup\` to record it`
+    : '';
   const issues = [
-    formatNodePathIssue('runtime', recorded),
+    formatLaunchCheckIssue(launchCheck),
+    launcherCovers ? '' : formatNodePathIssue('runtime', recorded),
     formatNodePathIssue('reminder', reminder)
   ].filter(Boolean);
   return {
     runtimeFile: runtimeInfoPath(),
+    launchCommand: [launch.command, ...launch.argsPrefix].join(' '),
+    launchStatus: launchCheck?.status || 'unknown',
+    launchNode: launchCheck?.node || '',
+    launchVersion: launchCheck?.version || '',
     recordedNode: runtime?.nodePath || '',
     recordedVersion: runtime?.nodeVersion || '',
     recordedStatus: recorded.status,
+    recordedNote,
     reminderNode: reminderNode || '',
     reminderStatus: reminder.status,
     issues
   };
 }
 
+// The `logwork` entry of each MCP client config (what `logwork mcp status`
+// shows). Read-only.
+export async function collectMcpClientCheck({
+  ctx = createMcpInstallContext()
+} = {}) {
+  const clients = await inspectMcpClients(ctx);
+  return clients.filter((client) => client.detected).map((client) => ({
+    label: client.label,
+    status: client.status,
+    reason: client.reason,
+    legacy: client.legacy,
+    localScopes: (client.localScopes || []).length
+  }));
+}
+
+function formatMcpClientCheck(client) {
+  const extra = [
+    client.reason,
+    client.legacy ? 'leftover logwork-helper entry' : '',
+    client.localScopes ? `${client.localScopes} stale local-scope entries` : ''
+  ].filter(Boolean).join('; ');
+  return `${client.label}: ${client.status}${extra ? ` (${extra})` : ''}`;
+}
+
 async function readPackageInfo({ readFileFn }) {
   try {
     const packagePath = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');