logwork-cli 1.0.0 → 1.1.0

package/README.md

@@ -67,12 +67,14 @@ Sessions are stored in macOS Keychain or Windows Credential Manager. The default
 ```text
 logwork                 Open the terminal UI
 logwork query [period]  Booked vs logged hours with entry ids (today, yesterday, this-week, last-week, this-month, last-month)
+logwork commits [period] Draft logwork lines from your git commits (--repo, --author)
 logwork quick [-m text] Log one entry for today with guided prompts
 logwork edit <id> ...   Change an existing RO entry (replaces it)
 logwork delete <id>     Delete a submitted or approved RO entry
 logwork reconcile       Compare RO and Jira hours by day (read-only)
 logwork history         Local apply history
 logwork login|logout|status [ro|jira]
+logwork skill install   Install the AI agent skill (Claude Code, Codex)
 logwork setup           Install the runtime and print MCP configs
 logwork mcp             Run the MCP stdio server (used by IDE configs)
 logwork reminder ...    Weekday logwork reminder
@@ -82,6 +84,47 @@ logwork doctor          Write a sanitized diagnostics report
 
 Add `--help` to any command for its options.
 
+## Log Work From Your Commits
+
+Most logwork is the work you committed. logwork turns your commits into draft lines, and the RO booking decides how many hours there are to fill.
+
+```bash
+logwork commits yesterday
+logwork commits this-week --repo ~/code/portal --repo ~/code/api
+```
+
+How the draft is built:
+
+- **Which commits:** your own (`git config user.email`, or `--author`) on every local and remote branch. Stashes and merge commits are skipped.
+- **Grouping:** per day, by repo + ticket key + kind of work.
+- **Worklog task:** chosen from the kind of work.
+
+  | Commit | Worklog task |
+  |---|---|
+  | `feat` | Feature Development |
+  | `fix`, hotfix | Bug Fix |
+  | `refactor`, `perf`, review | Code Review & Refactoring |
+  | `test` | Testing Activities |
+  | `ci`, `build`, release, deploy | Deployment & Release |
+  | `docs`, design | Requirements & Design |
+  | `chore` | Other Activities |
+
+  Conventional prefixes are used first, then keywords in the subject.
+- **Hours:** each day's RO remaining time (booked − logged, per project) is split across the groups in 0.5h steps, weighted by commits and lines changed. Days without a booking get 0h. Without RO access, a weekday counts as 8h.
+
+Nothing is written. Paste the draft into `/logwork`, or let your AI agent use it.
+
+For agents:
+- **MCP tool `draft_from_commits`** returns the same draft as `draftText`.
+- **MCP prompt `log_from_commits`** gives an agent the full procedure:
+  1. find gaps with `get_logwork`;
+  2. draft from commits;
+  3. check task names with `list_tasks`;
+  4. rewrite vague descriptions;
+  5. stay within booked hours;
+  6. get your approval, then `log_work`.
+- **Claude Code / Codex:** `logwork skill install` installs the same procedure as a skill, in `~/.claude/skills/logwork` and `~/.codex/skills/logwork`. For other agents, `logwork skill` prints it so you can paste it into your rules.
+
 ## Logwork Line Format
 
 Every Resource Optimiser entry has a **worklog task** and a free-text **description**. The worklog task is an RO catalog item such as `Feature Development` or `Code Review & Refactoring`. Write each line as:
@@ -154,7 +197,7 @@ claude mcp add --transport stdio logwork -- node ~/.logwork-cli/bin/logwork.mjs
 
 Restart or reload the IDE's MCP tools after saving.
 
-The server exposes 15 tools. It also sends `instructions` covering the approval rules, the line format and the recommended call order. Every write is **two calls to the same tool**:
+The server exposes 16 tools and one prompt (`log_from_commits`). It also sends `instructions` covering the approval rules, the line format and the recommended call order. Every write is **two calls to the same tool**:
 1. Call the tool without `confirm`. It returns a preview with a `batchId` or `previewId` and a summary.
 2. After the user approves, call the same tool again with only that id and `confirm: true`.
 

package/RELEASE.md

@@ -67,7 +67,7 @@ The gate must pass all of the following:
 - Confirm the printed MCP config uses server name `logwork` and `node ~/.logwork-cli/bin/logwork.mjs mcp`.
 - Run `logwork --help` and `logwork --version`.
 - Run `logwork update check --force` against the published npm version.
-- Run `logwork mcp` through an MCP client smoke test and confirm it lists the 15 tools (`get_logwork`, `list_projects`, `list_tasks`, `log_work`, `edit_entry`, `resubmit_entry`, `delete_entry`, `log_jira_work`, `get_jira_issue`, `reconcile`, `get_history`, `map_project`, `login`, `reminder`, `update`).
+- Run `logwork mcp` through an MCP client smoke test and confirm it lists the 16 tools (`get_logwork`, `draft_from_commits`, `list_projects`, `list_tasks`, `log_work`, `edit_entry`, `resubmit_entry`, `delete_entry`, `log_jira_work`, `get_jira_issue`, `reconcile`, `get_history`, `map_project`, `login`, `reminder`, `update`).
 - Confirm the `update` tool requires `confirm: true` for `action: "install"`, and `reconcile` takes preset periods only with no credential or confirmation fields.
 - Run `logwork reconcile this-week` and confirm it reports RO/Jira daily totals without writing either system.
 - On a machine with an older `logwork-helper` install, confirm the first run copies state to `~/.logwork-cli` and `logwork status` shows the existing session without a new login.

package/bin/logwork.mjs

@@ -10,6 +10,7 @@ import { readPackageVersion } from '../lib/package-info.mjs';
 //   logwork mcp           -> MCP stdio server for IDEs and agent CLIs
 export const COMMANDS = [
   { name: 'query', usage: 'query [today|yesterday|this-week|last-week|this-month|last-month] [--json]', summary: 'Show booked vs logged hours with entry ids', load: () => import('../commands/query.mjs'), fn: 'run' },
+  { name: 'commits', usage: 'commits [period] [--repo path]... [--author email]', summary: 'Draft logwork lines from your git commits', load: () => import('../commands/commits.mjs'), fn: 'run' },
   { name: 'quick', usage: 'quick [-m "what you did"]', summary: 'Log one entry for today with guided prompts', load: () => import('../commands/quick.mjs'), fn: 'run' },
   { name: 'edit', usage: 'edit <id> [--hours h] [--task name|#id] [--desc text] [--type type]', summary: 'Change an existing RO entry (replaces it)', load: () => import('../commands/edit.mjs'), fn: 'runRoEditCommand' },
   { name: 'delete', usage: 'delete <id>', summary: 'Delete a submitted or approved RO entry', load: () => import('../commands/delete.mjs'), fn: 'runRoDeleteCommand' },
@@ -18,6 +19,7 @@ export const COMMANDS = [
   { name: 'login', usage: 'login [ro|jira] [--base-url url]', summary: 'Log in to Resource Optimiser (default) or Jira', load: () => import('../commands/auth.mjs'), fn: 'runLogin' },
   { name: 'logout', usage: 'logout [ro|jira]', summary: 'Remove the stored RO (default) or Jira session', load: () => import('../commands/auth.mjs'), fn: 'runLogout' },
   { name: 'status', usage: 'status', summary: 'Show RO and Jira login status', load: () => import('../commands/auth.mjs'), fn: 'runStatus' },
+  { name: 'skill', usage: 'skill [print|install] [--target claude|codex|all]', summary: 'Print or install the AI agent skill for logging from commits', load: () => import('../commands/skill.mjs'), fn: 'run' },
   { name: 'setup', usage: 'setup [--login|--no-login]', summary: 'Install the runtime and print MCP configs', load: () => import('../commands/setup.mjs'), fn: 'run' },
   { name: 'mcp', usage: 'mcp', summary: 'Run the MCP stdio server (used by IDE configs)', load: () => import('../lib/mcp-server.mjs'), fn: 'startMcpServer' },
   { name: 'reminder', usage: 'reminder enable|disable|status|test', summary: 'Manage the weekday logwork reminder', load: () => import('../commands/reminder.mjs'), fn: 'runReminderCli' },
@@ -75,6 +77,7 @@ Examples:
   logwork setup
   logwork login
   logwork query this-week
+  logwork commits yesterday --repo ~/code/app
   logwork quick -m "Fix login bug (SCB-12)"
   logwork edit 304032 --task "Bug Fix" --desc "Fix date picker timezone (SAP-42)"
 

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/setup.mjs

@@ -435,6 +435,10 @@ export function formatSetupUserInstructions({
     'GitHub Copilot / VS Code mcp.json:',
     JSON.stringify(vscodeMcpConfig(entryPath), null, 2),
     '',
+    'AI agent skill (log work from your commits)',
+    '- Claude Code / Codex: run `logwork skill install`.',
+    '- Other MCP clients: use the MCP prompt "log_from_commits".',
+    '',
     'Verify',
     '- Restart or reload your IDE MCP tools after pasting config.',
     '- In the IDE, ask: Check my logwork for this week.',

package/commands/skill.mjs

@@ -0,0 +1,91 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { SKILL_NAME, readLogworkSkill } from '../lib/agent-skill.mjs';
+
+// `logwork skill`            print the agent skill (SKILL.md)
+// `logwork skill install`    copy it to ~/.claude/skills and ~/.codex/skills
+export const SKILL_TARGETS = Object.freeze({
+  claude: (home) => join(home, '.claude', 'skills', SKILL_NAME, 'SKILL.md'),
+  codex: (home) => join(home, '.codex', 'skills', SKILL_NAME, 'SKILL.md')
+});
+
+export function parseSkillArgs(args = []) {
+  const options = { action: 'print', targets: [], dir: undefined, 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 === '--target' || arg === '--dir') {
+      const value = args[index + 1];
+      if (!value || value.startsWith('--')) {
+        throw new Error(`${arg} requires a value.`);
+      }
+      if (arg === '--dir') {
+        options.dir = value;
+      } else {
+        options.targets.push(...value.split(','));
+      }
+      index += 1;
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown skill option: ${arg}`);
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (positional.length > 1 || (positional[0] && !['print', 'install'].includes(positional[0]))) {
+    throw new Error('Usage: logwork skill [print|install] [--target claude|codex|all] [--dir <path>]');
+  }
+  options.action = positional[0] || 'print';
+  const targets = options.targets.length ? options.targets : ['all'];
+  options.targets = targets.includes('all') ? Object.keys(SKILL_TARGETS) : targets;
+  for (const target of options.targets) {
+    if (!SKILL_TARGETS[target]) {
+      throw new Error(`Unknown skill target: ${target}. Use claude, codex or all.`);
+    }
+  }
+  return options;
+}
+
+export async function run(args = [], {
+  home = homedir(),
+  print = console.log,
+  mkdirFn = mkdir,
+  writeFileFn = writeFile
+} = {}) {
+  const options = parseSkillArgs(args);
+  if (options.help) {
+    print(formatSkillHelp());
+    return 0;
+  }
+  const content = `${readLogworkSkill({ withFrontmatter: true }).trim()}\n`;
+  if (options.action === 'print') {
+    print(content);
+    return 0;
+  }
+  const paths = options.dir
+    ? [join(resolve(options.dir), SKILL_NAME, 'SKILL.md')]
+    : options.targets.map((target) => SKILL_TARGETS[target](home));
+  for (const path of paths) {
+    await mkdirFn(join(path, '..'), { recursive: true });
+    await writeFileFn(path, content, 'utf8');
+    print(`Installed the logwork skill: ${path}`);
+  }
+  print('Restart the agent so it picks up the skill. The same procedure is served as the MCP prompt "log_from_commits".');
+  return 0;
+}
+
+export function formatSkillHelp() {
+  return `Usage:
+  logwork skill                        Print the agent skill (SKILL.md)
+  logwork skill install                Install it for Claude Code and Codex
+  logwork skill install --target claude|codex|all
+  logwork skill install --dir <path>   Install under <path>/logwork/SKILL.md
+                                       (for example a repo's .claude/skills)
+
+The skill tells an AI agent how to log accurate work from your git commits:
+get_logwork -> draft_from_commits -> list_tasks -> review with you -> log_work.
+Other agents (Cursor, Copilot) can use the MCP prompt "log_from_commits", or
+paste \`logwork skill\` output into their rules.`;
+}

package/docs/mcp-setup.md

@@ -73,7 +73,7 @@ If you used `logwork-helper` before, delete its old MCP entry. It points at `~/.
 
 ## Exposed Tools
 
-After editing the config, restart or reload the IDE. The server exposes 15 tools. Each one has a title, a description, a described input schema, and MCP annotations (`readOnlyHint`, `destructiveHint`, `idempotentHint`, `openWorldHint`), so IDEs and agents can tell read-only tools from writes.
+After editing the config, restart or reload the IDE. The server exposes 16 tools and one prompt. Each one has a title, a description, a described input schema, and MCP annotations (`readOnlyHint`, `destructiveHint`, `idempotentHint`, `openWorldHint`), so IDEs and agents can tell read-only tools from writes.
 
 The server also sends MCP `instructions` that explain the approval rules, the line format and the recommended call order. Most clients pass these to the model automatically.
 
@@ -89,6 +89,7 @@ Previews expire after 1 hour. They are also lost when the server restarts.
 | Group | Tool | Kind | Purpose |
 |---|---|---|---|
 | Read | `get_logwork` | read-only | Booked vs logged RO hours by day and project, with entries (`logworkId`, worklog task, description, status). |
+| Read | `draft_from_commits` | read-only | Your git commits (all branches, your author) for a period in the given `repos`, grouped per day into draft lines with a suggested worklog task and hours that fill the RO remaining booked time. Returns `draftText` for `log_work`. |
 | Read | `list_projects` | read-only | RO memberships (`projectMemberId`, `projectId`, `projectName`) and local mappings. |
 | Read | `list_tasks` | read-only | RO worklog task catalog for one `projectId`: id, name, type of work, and when to use each task. |
 | Read | `get_jira_issue` | read-only | Jira issue key, summary and status. |
@@ -172,8 +173,28 @@ Log 2 hours today for SCB-213 "maintenance mode UI" as Feature Development, with
 Set up the SCB ticket mapping to project 2621A-SIT-HTML BUILDER-PRJ.
 ```
 
+**Prompt `log_from_commits`** (arguments: `period`, `repos`) returns the full procedure for logging from commits. It is the same text as the agent skill that `logwork skill install` installs for Claude Code and Codex.
+
 ## Common MCP Workflows
 
+### Log Work From Your Commits
+
+Ask your assistant (or pick the `log_from_commits` prompt in clients that list MCP prompts):
+
+```text
+Log my work for yesterday from my commits in this workspace.
+```
+
+Expected flow:
+
+1. `get_logwork` shows which days and projects still have booked hours to fill.
+2. `draft_from_commits` (with `repos` set to the workspace folders) groups your commits into draft lines with hours.
+3. `list_tasks` confirms the worklog task names for each project.
+4. The assistant rewrites vague descriptions, shows you the block and waits for approval.
+5. `log_work(text)` previews the entries, then `log_work(batchId, confirm: true)` applies them.
+
+
+
 ### Query Logwork
 
 Ask your assistant:

package/lib/agent-skill.mjs

@@ -0,0 +1,16 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// skills/logwork/SKILL.md is the single source for the agent procedure: it is
+// shipped as an installable skill (`logwork skill install`) and served as the
+// MCP prompt log_from_commits.
+export const SKILL_NAME = 'logwork';
+export const SKILL_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'skills', SKILL_NAME, 'SKILL.md');
+
+export function readLogworkSkill({ withFrontmatter = false, path = SKILL_PATH } = {}) {
+  // Normalise CRLF (Windows git checkouts) so the frontmatter strip and the
+  // installed copies are identical on every platform.
+  const text = readFileSync(path, 'utf8').replace(/\r\n/g, '\n');
+  return withFrontmatter ? text : text.replace(/^---\n[\s\S]*?\n---\n+/, '').trim();
+}

package/lib/commit-workflow.mjs

@@ -0,0 +1,402 @@
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { CONFIG } from './config.mjs';
+import { normalizeQueryRange, queryLogwork } from './query-workflow.mjs';
+import { addLocalDays, todayLocalDateISO } from './util.mjs';
+
+// Builds a logwork draft from the user's own git commits:
+//   commits (all branches, this author, in the period)
+//   -> grouped per day by repo + ticket + kind of work
+//   -> each group gets a default RO worklog task and a description
+//   -> the day's hours (RO booked - logged, or a standard day) are split across
+//      groups by how much work each group holds
+//   -> a "+<hours> <worklog task> | <description>" block for log_work.
+// Nothing is written anywhere; the agent shows the draft, the user edits and
+// approves it, then log_work previews and applies it as usual.
+
+const TICKET_RE = /\b[A-Z][A-Z0-9]+-\d+\b/g;
+const CONVENTIONAL_RE = /^(\w+)(?:\([^)]*\))?!?:\s*/;
+const FIELD = '\x1f';
+const RECORD = '\x1e';
+const MAX_DESCRIPTION_LENGTH = 240;
+
+// 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).
+export const WORK_KINDS = Object.freeze({
+  feature: { task: 'Feature Development', label: 'feature' },
+  fix: { task: 'Bug Fix', label: 'fix' },
+  refactor: { task: 'Code Review & Refactoring', label: 'refactor/review' },
+  test: { task: 'Testing Activities', label: 'test' },
+  release: { task: 'Deployment & Release', label: 'build/deploy' },
+  design: { task: 'Requirements & Design', label: 'docs/design' },
+  other: { task: 'Other Activities', label: 'other' }
+});
+
+const CONVENTIONAL_KINDS = new Map([
+  ['feat', 'feature'], ['feature', 'feature'],
+  ['fix', 'fix'], ['bugfix', 'fix'], ['hotfix', 'fix'], ['revert', 'fix'],
+  ['refactor', 'refactor'], ['perf', 'refactor'], ['style', 'refactor'], ['review', 'refactor'],
+  ['test', 'test'], ['tests', 'test'], ['e2e', 'test'],
+  ['ci', 'release'], ['build', 'release'], ['release', 'release'], ['deploy', 'release'],
+  ['docs', 'design'], ['doc', 'design'], ['design', 'design'], ['spec', 'design'],
+  ['chore', 'other']
+]);
+
+// Keyword fallback for non-conventional subjects, strongest signal first.
+const KEYWORD_KINDS = [
+  [/\b(fix|fixes|fixed|bug|hotfix|crash|regression)\b/i, 'fix'],
+  [/\b(tests?|e2e|unit test|coverage|qa)\b/i, 'test'],
+  [/\b(deploy|deployment|release|bump|pipeline|docker|helm|k8s|kubernetes)\b/i, 'release'],
+  [/\b(refactor|cleanup|clean up|rename|review|lint|format)\b/i, 'refactor'],
+  [/\b(docs?|readme|design|spec|requirements?|diagram)\b/i, 'design']
+];
+
+export function classifyCommit(subject = '', body = '') {
+  const conventional = CONVENTIONAL_RE.exec(subject);
+  if (conventional) {
+    const kind = CONVENTIONAL_KINDS.get(conventional[1].toLowerCase());
+    if (kind) {
+      return kind;
+    }
+  }
+  for (const text of [subject, body]) {
+    for (const [pattern, kind] of KEYWORD_KINDS) {
+      if (pattern.test(text)) {
+        return kind;
+      }
+    }
+  }
+  return 'feature';
+}
+
+export function cleanSubject(subject = '') {
+  return String(subject).replace(CONVENTIONAL_RE, '').trim();
+}
+
+export function parseGitLog(output = '') {
+  const commits = [];
+  for (const chunk of String(output).split(RECORD)) {
+    if (!chunk.trim()) {
+      continue;
+    }
+    const [hash, timestamp, authorName, authorEmail, subject, body = '', stats = ''] = chunk.split(FIELD);
+    if (!hash || !timestamp) {
+      continue;
+    }
+    let additions = 0;
+    let deletions = 0;
+    let files = 0;
+    for (const line of stats.split(/\r?\n/)) {
+      const match = /^(\d+|-)\t(\d+|-)\t/.exec(line.trim());
+      if (match) {
+        files += 1;
+        additions += match[1] === '-' ? 0 : Number(match[1]);
+        deletions += match[2] === '-' ? 0 : Number(match[2]);
+      }
+    }
+    commits.push({
+      hash: hash.trim(),
+      timestamp: Number(timestamp),
+      authorName: authorName.trim(),
+      authorEmail: authorEmail.trim(),
+      subject: subject.trim(),
+      body: body.trim(),
+      files,
+      additions,
+      deletions
+    });
+  }
+  return commits;
+}
+
+export async function readRepoCommits({ repo, from, to, author, runGit = runGitCommand }) {
+  const root = (await runGit(repo, ['rev-parse', '--show-toplevel'])).trim();
+  const authorFilter = author || (await runGit(root, ['config', 'user.email']).catch(() => '')).trim();
+  if (!authorFilter) {
+    throw new Error(`No git author for ${root}. Set git config user.email or pass author.`);
+  }
+  const output = await runGit(root, [
+    'log',
+    // Every local and remote branch (work often sits on feature branches), but
+    // not refs/stash, whose "WIP on"/"index on" commits are not work items.
+    '--branches',
+    '--remotes',
+    '--no-merges',
+    `--since=${from}T00:00:00`,
+    `--until=${to}T00:00:00`,
+    `--author=${authorFilter}`,
+    '--regexp-ignore-case',
+    `--format=${RECORD}%H${FIELD}%at${FIELD}%an${FIELD}%ae${FIELD}%s${FIELD}%b${FIELD}`,
+    '--numstat'
+  ]);
+  const seen = new Set();
+  const commits = parseGitLog(output)
+    .filter((commit) => !seen.has(commit.hash) && seen.add(commit.hash))
+    .map((commit) => ({ ...commit, repo: root, date: todayLocalDateISO(new Date(commit.timestamp * 1000)) }))
+    .filter((commit) => commit.date >= from && commit.date < to);
+  return { root, author: authorFilter, commits };
+}
+
+export function groupCommits(commits = []) {
+  const groups = new Map();
+  for (const commit of [...commits].sort((a, b) => a.timestamp - b.timestamp)) {
+    const tickets = [...new Set(`${commit.subject}\n${commit.body}`.match(TICKET_RE) || [])];
+    const kind = classifyCommit(commit.subject, commit.body);
+    const key = [commit.repo, tickets[0] || '', kind].join('|');
+    const group = groups.get(key) || {
+      repo: commit.repo,
+      repoName: commit.repo.split(/[\\/]/).filter(Boolean).pop() || commit.repo,
+      tickets: [],
+      kind,
+      task: WORK_KINDS[kind].task,
+      subjects: [],
+      commitCount: 0,
+      linesChanged: 0,
+      hashes: []
+    };
+    group.tickets = [...new Set([...group.tickets, ...tickets])];
+    const subject = cleanSubject(commit.subject);
+    if (subject && !group.subjects.includes(subject)) {
+      group.subjects.push(subject);
+    }
+    group.commitCount += 1;
+    group.linesChanged += commit.additions + commit.deletions;
+    group.hashes.push(commit.hash.slice(0, 8));
+    groups.set(key, group);
+  }
+  return [...groups.values()].map((group) => ({
+    ...group,
+    description: buildDescription(group),
+    weight: group.commitCount + Math.min(3, group.linesChanged / 200)
+  }));
+}
+
+export function buildDescription(group) {
+  const ticketSuffix = group.tickets.length ? ` (${group.tickets.join(', ')})` : '';
+  const room = MAX_DESCRIPTION_LENGTH - ticketSuffix.length;
+  const subjects = group.subjects.map((subject) => subject.replace(TICKET_RE, '').replace(/\s*[[(]\s*[)\]]\s*/g, ' ').replace(/\s+/g, ' ').trim()).filter(Boolean);
+  let text = '';
+  for (const subject of subjects) {
+    const next = text ? `${text}; ${subject}` : subject;
+    if (next.length > room) {
+      text = text || subject.slice(0, Math.max(0, room - 1)).trim();
+      break;
+    }
+    text = next;
+  }
+  return `${text || group.repoName}${ticketSuffix}`.replace(/\|/g, '/');
+}
+
+// Splits targetHours across groups by weight in hourStep increments. Every
+// group that gets time gets at least one step; when the day has fewer steps than
+// groups, the heaviest groups win and the rest get 0 (still listed).
+export function allocateHours(groups, targetHours, step = CONFIG.hourStep || 0.5) {
+  const totalSteps = Math.max(0, Math.floor((Number(targetHours) || 0) / step + 1e-9));
+  const ordered = groups.map((group, index) => ({ index, weight: group.weight || 1 }))
+    .sort((a, b) => b.weight - a.weight);
+  const steps = new Array(groups.length).fill(0);
+  if (!totalSteps || !groups.length) {
+    return steps.map(() => 0);
+  }
+  const funded = ordered.slice(0, Math.min(totalSteps, ordered.length));
+  for (const item of funded) {
+    steps[item.index] = 1;
+  }
+  let remaining = totalSteps - funded.length;
+  const totalWeight = funded.reduce((sum, item) => sum + item.weight, 0);
+  const shares = funded.map((item) => ({ ...item, exact: (item.weight / totalWeight) * remaining }));
+  for (const share of shares) {
+    const whole = Math.floor(share.exact);
+    steps[share.index] += whole;
+    remaining -= whole;
+  }
+  shares.sort((a, b) => (b.exact - Math.floor(b.exact)) - (a.exact - Math.floor(a.exact)));
+  for (let i = 0; remaining > 0; i = (i + 1) % shares.length) {
+    steps[shares[i].index] += 1;
+    remaining -= 1;
+  }
+  return steps.map((count) => Number((count * step).toFixed(2)));
+}
+
+export function formatDayHeading(localDateISO) {
+  const [year, month, day] = localDateISO.split('-').map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  const weekday = date.toLocaleDateString('en-US', { weekday: 'long', timeZone: 'UTC' });
+  const monthName = date.toLocaleDateString('en-US', { month: 'short', timeZone: 'UTC' });
+  return `${weekday}, ${String(day).padStart(2, '0')} ${monthName} ${year}`;
+}
+
+function isWeekend(localDateISO) {
+  const [year, month, day] = localDateISO.split('-').map(Number);
+  const weekday = new Date(Date.UTC(year, month - 1, day)).getUTCDay();
+  return weekday === 0 || weekday === 6;
+}
+
+// Remaining RO time per day: sum over projects of max(0, booked - logged), so
+// over-logging one project does not hide a gap on another.
+export function remainingHoursByDay(roResult) {
+  const byDay = new Map();
+  for (const day of roResult?.days || []) {
+    const projects = day.projects || [];
+    const remaining = projects.length
+      ? projects.reduce((sum, project) => sum + Math.max(0, Number(project.bookedHours || 0) - Number(project.loggedHours || 0)), 0)
+      : Math.max(0, Number(day.bookedHours || 0) - Number(day.loggedHours || 0));
+    byDay.set(day.date, {
+      bookedHours: Number(day.bookedHours || 0),
+      loggedHours: Number(day.loggedHours || 0),
+      remainingHours: Number(remaining.toFixed(2))
+    });
+  }
+  return byDay;
+}
+
+export async function draftLogworkFromCommits({
+  period = 'today',
+  from,
+  to,
+  repos,
+  author,
+  useBookings = true,
+  cwd = process.cwd(),
+  runGit = runGitCommand,
+  queryRo = queryLogwork
+} = {}) {
+  const range = from || to ? normalizeQueryRange({ from, to }) : normalizeQueryRange({ period });
+  const repoPaths = [...new Set((repos?.length ? repos : [cwd]).map((repo) => resolve(cwd, String(repo))))];
+
+  const repoResults = [];
+  const commits = [];
+  for (const repo of repoPaths) {
+    try {
+      const result = await readRepoCommits({ repo, from: range.from, to: range.to, author, runGit });
+      repoResults.push({ path: result.root, author: result.author, commitCount: result.commits.length });
+      commits.push(...result.commits);
+    } catch (error) {
+      repoResults.push({ path: repo, error: error.message, commitCount: 0 });
+    }
+  }
+
+  let bookings = null;
+  let bookingsError = '';
+  if (useBookings) {
+    try {
+      bookings = remainingHoursByDay(await queryRo({ from: range.from, to: range.to, includeEntries: false, cwd }));
+    } catch (error) {
+      bookingsError = error.message;
+    }
+  }
+
+  const days = [];
+  for (let date = range.from; date < range.to; date = addLocalDays(date, 1)) {
+    const dayCommits = commits.filter((commit) => commit.date === date);
+    if (!dayCommits.length) {
+      continue;
+    }
+    const groups = groupCommits(dayCommits);
+    const booking = bookings?.get(date);
+    let targetHours;
+    let hoursSource;
+    if (booking) {
+      targetHours = booking.remainingHours;
+      hoursSource = booking.bookedHours ? 'ro_remaining' : 'ro_no_booking';
+    } else if (bookings) {
+      // RO answered but has no row for this day: nothing is booked.
+      targetHours = 0;
+      hoursSource = 'ro_no_booking';
+    } else {
+      targetHours = isWeekend(date) ? 0 : (CONFIG.standardDayHours || 8);
+      hoursSource = isWeekend(date) ? 'weekend' : 'standard_day';
+    }
+    const hours = allocateHours(groups, targetHours);
+    days.push({
+      date,
+      targetHours,
+      hoursSource,
+      ...(booking ? { bookedHours: booking.bookedHours, loggedHours: booking.loggedHours } : {}),
+      groups: groups.map((group, index) => ({
+        hours: hours[index],
+        task: group.task,
+        kind: group.kind,
+        description: group.description,
+        tickets: group.tickets,
+        repo: group.repoName,
+        commitCount: group.commitCount,
+        linesChanged: group.linesChanged,
+        commits: group.hashes
+      }))
+    });
+  }
+
+  const draftText = days
+    .map((day) => {
+      const lines = day.groups.filter((group) => group.hours > 0)
+        .map((group) => `+${group.hours} ${group.task} | ${group.description}`);
+      return lines.length ? [formatDayHeading(day.date), ...lines].join('\n') : '';
+    })
+    .filter(Boolean)
+    .join('\n\n');
+
+  const result = {
+    status: commits.length ? 'draft' : 'no_commits',
+    range,
+    repos: repoResults,
+    bookings: useBookings ? (bookings ? 'ro' : 'unavailable') : 'skipped',
+    ...(bookingsError ? { bookingsError } : {}),
+    commitCount: commits.length,
+    days,
+    draftText
+  };
+  result.summary = formatCommitDraftSummary(result);
+  return result;
+}
+
+export function formatCommitDraftSummary(result) {
+  const lines = [];
+  if (!result.commitCount) {
+    lines.push(`No commits found from ${result.range.from} to ${addLocalDays(result.range.to, -1)}.`);
+  } else {
+    lines.push(`${result.commitCount} commit(s) from ${result.range.from} to ${addLocalDays(result.range.to, -1)}.`);
+  }
+  for (const repo of result.repos) {
+    lines.push(repo.error ? `- ${repo.path}: ${repo.error}` : `- ${repo.path} (${repo.author}): ${repo.commitCount} commit(s)`);
+  }
+  if (result.bookings === 'unavailable') {
+    lines.push(`RO bookings unavailable (${result.bookingsError || 'unknown error'}); hours assume a ${CONFIG.standardDayHours || 8}h weekday.`);
+  }
+  for (const day of result.days) {
+    const source = {
+      ro_remaining: `RO remaining ${day.targetHours}h (booked ${day.bookedHours}h, logged ${day.loggedHours}h)`,
+      ro_no_booking: 'no RO booking: 0h suggested',
+      weekend: 'weekend: 0h suggested',
+      standard_day: `standard day ${day.targetHours}h`
+    }[day.hoursSource];
+    lines.push('', `${formatDayHeading(day.date)} - ${source}`);
+    for (const group of day.groups) {
+      lines.push(`  +${group.hours} ${group.task} | ${group.description}  [${group.repo}, ${group.commitCount} commit(s)]`);
+    }
+  }
+  if (result.draftText) {
+    lines.push('', 'Draft for log_work (review with the user first; worklog task names must exist in list_tasks for the project):', '', result.draftText);
+  }
+  return lines.join('\n');
+}
+
+function runGitCommand(cwd, args) {
+  return new Promise((resolveValue, reject) => {
+    const child = spawn('git', ['-C', cwd, ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolveValue(stdout);
+        return;
+      }
+      reject(new Error(stderr.trim().split('\n')[0] || `git ${args[0]} failed with exit code ${code}`));
+    });
+  });
+}

package/lib/mcp-server.mjs

@@ -3,6 +3,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import { ApiError } from './api.mjs';
 import { queryApplyLedger } from './apply-ledger.mjs';
+import { readLogworkSkill } from './agent-skill.mjs';
+import { draftLogworkFromCommits } from './commit-workflow.mjs';
 import {
   applyLogworkBatch,
   formatToolResponse,
@@ -73,7 +75,8 @@ Logwork text format (log_work and log_jira_work):
 - Lines without "|" are accepted only when the text is itself a catalog task name (no description is written), or when defaultWorklogTask is passed (the text then becomes the description).
 - Jira needs exactly one issue key such as SCB-213 in the line.
 
-Recommended RO flow: get_logwork (what is booked/logged) -> list_projects -> list_tasks(projectId) -> log_work(text) -> user approval -> log_work(batchId, confirm: true).
+Recommended RO flow: get_logwork (what is booked/logged) -> draft_from_commits (the user's git commits as draft lines) -> list_tasks(projectId) -> log_work(text) -> user approval -> log_work(batchId, confirm: true).
+Base every line on the user's commits or on what the user tells you; never invent work. The log_from_commits prompt has the full procedure.
 Fixing existing RO entries (logworkId from get_logwork): submitted/approved entries -> edit_entry (hours, worklog task, type of work, description; apply replaces the entry with a new id, approved immediately); rejected entries -> resubmit_entry; removing an entry -> delete_entry.
 If a preview entry is unresolved: worklog_task_required / task_not_found means fix the worklog task (see availableTaskNames); project reasons mean ask the user to pick a project (projectOverrides) or save a mapping with map_project.`;
 
@@ -128,6 +131,20 @@ server.registerTool('list_tasks', {
   }
 }, withAuthRequiredHandling(async ({ projectId }) => formatToolResponse(await listWorklogTasks({ projectId }))));
 
+server.registerTool('draft_from_commits', {
+  title: 'Draft logwork from git commits',
+  description: 'Read-only: read the user\'s own git commits (all branches, git user.email) in one or more repos for a period, group them per day by repo + ticket + kind of work, suggest an RO worklog task per group (feat -> Feature Development, fix -> Bug Fix, refactor/review -> Code Review & Refactoring, test -> Testing Activities, ci/build/release -> Deployment & Release, docs -> Requirements & Design), and split each day\'s remaining RO hours (booked - logged) across the groups. Returns draftText in the log_work line format. Review it with the user, check task names with list_tasks, then pass it to log_work.',
+  annotations: READ_ONLY,
+  inputSchema: {
+    period: z.enum(PERIOD_VALUES).optional().describe('Preset period. Defaults to today.'),
+    repos: z.array(z.string().min(1)).max(20).optional().describe('Absolute paths of the git repos the user worked in (for example the open workspace folders). Defaults to the MCP server working directory.'),
+    author: z.string().min(1).optional().describe('Git author filter (email or name). Defaults to each repo\'s git config user.email.'),
+    useBookings: z.boolean().optional().describe('Split hours by RO remaining booked time per day (default true). When false or RO is unavailable, a weekday counts as 8h.')
+  }
+}, withAuthRequiredHandling(async ({ period, repos, author, useBookings = true }) => {
+  return formatToolResponse(await draftLogworkFromCommits({ period, repos, author, useBookings }));
+}));
+
 server.registerTool('log_work', {
   title: 'Log work to Resource Optimiser',
   description: `Resource Optimiser only: create new RO entries (worklog task + hours + date + type of work + description) from a weekly logwork block. ${TWO_STEP} The preview resolves the project (bookings, mappings, ticket prefixes) and worklog task per line; unresolved lines block apply. Use log_jira_work for Jira.`,
@@ -373,6 +390,29 @@ server.registerTool('update', {
   return formatToolResponse(await installUpdate({ version, confirm, stdio: 'pipe' }));
 });
 
+server.registerPrompt('log_from_commits', {
+  title: 'Log work from my commits',
+  description: 'Step-by-step procedure for logging accurate Resource Optimiser (and optionally Jira) work from the user\'s git commits.',
+  argsSchema: {
+    period: z.string().optional().describe('today, yesterday, this_week, last_week, this_month or last_month. Defaults to today.'),
+    repos: z.string().optional().describe('Comma-separated absolute repo paths. Defaults to the open workspace.')
+  }
+}, ({ period, repos }) => ({
+  messages: [{
+    role: 'user',
+    content: {
+      type: 'text',
+      text: [
+        readLogworkSkill(),
+        '',
+        `Period: ${period || 'today'}.`,
+        repos ? `Repos: ${repos}.` : 'Repos: the folders open in this workspace (ask me if there are others).',
+        'Start with get_logwork, then draft_from_commits.'
+      ].join('\n')
+    }
+  }]
+}));
+
 export async function startMcpServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logwork-cli",
-  "version": "1.0.0",
+  "version": "1.1.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",
@@ -38,6 +38,7 @@
     "bin/",
     "commands/",
     "lib/",
+    "skills/",
     "docs/",
     "examples/mcp/",
     "setup.sh",

package/skills/logwork/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: logwork
+description: Log work hours to Resource Optimiser (RO) and Jira from the user's own git commits with the logwork MCP tools. Use when the user asks to log work, fill in logwork or timesheets for a day or week, check missing hours, or fix existing RO entries.
+---
+
+# Logwork from commits
+
+Goal: every logged line is backed by real work (the user's commits or what the user tells you), uses a valid RO worklog task, has a clear description, and fits the day's booked hours.
+
+## 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.
+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.
+   - 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.
+7. **Get approval, then write.**
+   - Show the final block to the user.
+   - On approval, call `log_work(text)` and show its preview summary.
+   - 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.
+
+## Line format
+
+```text
+Friday, 06 Nov 2026
++2 Feature Development | Implement SSO login with ADFS (STM-4)
++1 Bug Fix | Fix date picker timezone offset (SAP-42)
+```
+
+`+<hours> <worklog task> | <description>`. The task is an RO catalog name or `#<id>`.
+
+## Rules
+
+- Never invent work that is not in the commits or in what the user told you. When unsure, ask.
+- Never set `confirm: true` without the user's explicit approval of that preview.
+- Never ask for or pass passwords, OTPs or tokens. On `authRequired`, call `login` and let the user finish in the terminal.
+- To fix an existing entry, use `edit_entry` (submitted or approved entries) or `resubmit_entry` (rejected entries). Do not log a duplicate.