logwork-cli 1.1.0 → 1.2.0

package/lib/jira-workflow.mjs

@@ -2,11 +2,12 @@ import { createHash } from 'node:crypto';
 import { CONFIG } from './config.mjs';
 import { recordApplyResult, recordApplyResultSafely } from './apply-ledger.mjs';
 import { parseWeeklyLogText } from './batch-parser.mjs';
-import { ApiError } from './api.mjs';
+import { ApiError } from './ro-api-http.mjs';
 import {
   addJiraIssueWorklog,
   getJiraIssue,
-  getJiraIssueWorklogs
+  getJiraIssueWorklogs,
+  isJiraDryRunResult
 } from './jira-api.mjs';
 import {
   createJiraAuthRequiredError,
@@ -148,6 +149,25 @@ export async function applyJiraWorklogBatch({
     const payload = entry.worklog || buildJiraWorklogPayload(entry);
     try {
       const worklog = await submitter(entry.issueKey, payload);
+      if (isJiraDryRunResult(worklog)) {
+        // LOGWORK_DRY_RUN=1: Jira was not called. Keep only the request so the
+        // caller can see what apply would send.
+        results.push({
+          entryId: entry.id,
+          issueKey: entry.issueKey,
+          date: entry.date,
+          hours: entry.hours,
+          taskName: entry.taskName,
+          status: 'dry_run',
+          dryRun: true,
+          request: {
+            method: worklog.method,
+            path: worklog.path,
+            body: worklog.body
+          }
+        });
+        continue;
+      }
       results.push({
         entryId: entry.id,
         issueKey: entry.issueKey,
@@ -173,9 +193,13 @@ export async function applyJiraWorklogBatch({
   }
 
   const failed = results.some((result) => result.status === 'failed');
+  const dryRun = results.some((result) => result.dryRun);
   const output = {
     batchId: batch.batchId,
-    status: failed ? (results.some((result) => result.status === 'submitted') ? 'partial_failed' : 'failed') : 'submitted',
+    status: failed
+      ? (results.some((result) => result.status === 'submitted') ? 'partial_failed' : 'failed')
+      : (dryRun ? 'dry_run' : 'submitted'),
+    dryRun,
     results,
     summary: formatJiraApplySummary(results)
   };
@@ -395,9 +419,15 @@ function formatJiraApplyBlockedSummary(blockedEntries) {
 function formatJiraApplySummary(results) {
   const submitted = results.filter((result) => result.status === 'submitted');
   const failed = results.filter((result) => result.status === 'failed');
-  const lines = [
-    `Jira worklog apply: submitted ${submitted.length}, failed ${failed.length}.`
-  ];
+  const dryRun = results.filter((result) => result.dryRun);
+  const lines = dryRun.length
+    ? [
+      'DRY RUN (LOGWORK_DRY_RUN=1): Jira worklog requests generated; nothing was written to Jira.',
+      `Jira worklog dry run: ${dryRun.length} request${dryRun.length === 1 ? '' : 's'}, submitted ${submitted.length}, failed ${failed.length}.`
+    ]
+    : [
+      `Jira worklog apply: submitted ${submitted.length}, failed ${failed.length}.`
+    ];
   for (const result of results) {
     lines.push(`- ${result.date}: ${result.issueKey} +${formatHours(result.hours)}h -> ${result.status}${result.error ? ` (${result.error})` : ''}`);
   }

package/lib/keychain.mjs

@@ -41,16 +41,9 @@ export function createKeychainValueStorage({
     },
 
     async set(token) {
-      await run([
-        'add-generic-password',
-        '-U',
-        '-s',
-        service,
-        '-a',
-        account,
-        '-w',
-        token
-      ]);
+      // The value goes in on stdin (security's interactive mode, as hex), never
+      // in argv where `ps` could show it.
+      await run(['-i'], { input: formatAddPasswordCommand({ service, account, value: token }) });
     },
 
     async delete() {
@@ -67,11 +60,25 @@ export function createKeychainValueStorage({
   };
 }
 
-function runSecurity(args) {
+export function formatAddPasswordCommand({ service, account, value }) {
+  for (const [label, text] of [['service', service], ['account', account]]) {
+    if (!/^[A-Za-z0-9._@+-]+$/.test(String(text))) {
+      throw new Error(`Unsupported Keychain ${label} name: ${text}`);
+    }
+  }
+  const hex = Buffer.from(String(value), 'utf8').toString('hex');
+  return `add-generic-password -U -s "${service}" -a "${account}" -X ${hex}\n`;
+}
+
+function runSecurity(args, { input } = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn('/usr/bin/security', args, {
-      stdio: ['ignore', 'pipe', 'pipe']
+      stdio: [input === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe']
     });
+    if (input !== undefined) {
+      child.stdin.on('error', () => {});
+      child.stdin.end(input);
+    }
 
     let stdout = '';
     let stderr = '';

package/lib/logwork-config.mjs

@@ -1,4 +1,6 @@
 import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
 import {
   legacyUserConfigPath,
   projectConfigPath,
@@ -29,6 +31,7 @@ export async function upsertProjectMappingConfig({
   project,
   tickets = [],
   keywords = [],
+  repos = [],
   lockOptions = {}
 }) {
   const path = scope === 'project' ? projectConfigPath(cwd) : userConfigPath();
@@ -39,25 +42,19 @@ export async function upsertProjectMappingConfig({
         normalizeConfig(await readRawConfigPath(legacyUserConfigPath())),
         normalizeConfig(await readRawConfigPath(path))
       );
-    const mapping = {
+    const mapping = withRepos({
       projectName: project.projectName,
       projectMemberId: project.projectMemberId,
       tickets: normalizeTickets(tickets),
       keywords: normalizeKeywords(keywords)
-    };
+    }, normalizeRepos(repos));
     const existingIndex = config.projectMappings.findIndex((candidate) => (
       sameProjectIdentity(candidate, mapping)
     ));
 
     const projectMappings = [...config.projectMappings];
     if (existingIndex >= 0) {
-      const existing = projectMappings[existingIndex];
-      projectMappings[existingIndex] = {
-        projectName: mapping.projectName || existing.projectName,
-        projectMemberId: mapping.projectMemberId ?? existing.projectMemberId,
-        tickets: uniqueStrings([...existing.tickets, ...mapping.tickets], { uppercase: true }),
-        keywords: uniqueStrings([...existing.keywords, ...mapping.keywords])
-      };
+      projectMappings[existingIndex] = mergeMapping(projectMappings[existingIndex], mapping);
     } else {
       projectMappings.push(mapping);
     }
@@ -133,21 +130,75 @@ function mappingKey(mapping) {
 }
 
 function normalizeMapping(mapping) {
-  return {
+  return withRepos({
     projectName: stringOrEmpty(mapping.projectName),
     projectMemberId: optionalId(mapping.projectMemberId),
     tickets: normalizeTickets(mapping.tickets),
     keywords: normalizeKeywords(mapping.keywords)
-  };
+  }, normalizeRepos(mapping.repos));
 }
 
 function mergeMapping(existing, next) {
-  return {
+  return withRepos({
     projectName: next.projectName || existing.projectName,
     projectMemberId: next.projectMemberId ?? existing.projectMemberId,
     tickets: uniqueStrings([...existing.tickets, ...next.tickets], { uppercase: true }),
     keywords: uniqueStrings([...existing.keywords, ...next.keywords])
-  };
+  }, normalizeRepos([...(existing.repos || []), ...(next.repos || [])]));
+}
+
+// repos is optional: a mapping without repos keeps its old shape on disk.
+function withRepos(mapping, repos) {
+  return repos.length ? { ...mapping, repos } : mapping;
+}
+
+// Git repo roots are stored resolved and without trailing separators. Windows
+// paths compare case-insensitively (see repoPathKey).
+export function normalizeRepoPath(value, platform = process.platform) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  if (!text) {
+    return '';
+  }
+  const pathApi = platform === 'win32' ? path.win32 : path.posix;
+  const expanded = text === '~' || /^~[\\/]/.test(text) ? `${homedir()}${text.slice(1)}` : text;
+  const resolved = pathApi.resolve(expanded);
+  const root = pathApi.parse(resolved).root;
+  let trimmed = resolved;
+  while (trimmed.length > root.length && /[\\/]$/.test(trimmed)) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
+}
+
+export function repoPathKey(value, platform = process.platform) {
+  const normalized = normalizeRepoPath(value, platform);
+  return platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+export function normalizeRepos(value, platform = process.platform) {
+  const seen = new Set();
+  const results = [];
+  for (const item of stringArray(value)) {
+    const normalized = normalizeRepoPath(item, platform);
+    const key = repoPathKey(normalized, platform);
+    if (!normalized || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    results.push(normalized);
+  }
+  return results;
+}
+
+// The mapping whose repos list contains this git repo root, if any.
+export function findRepoMapping(mappings, repoRoot, platform = process.platform) {
+  const key = repoPathKey(repoRoot, platform);
+  if (!key) {
+    return null;
+  }
+  return (mappings || []).find((mapping) => (
+    (mapping.repos || []).some((repo) => repoPathKey(repo, platform) === key)
+  )) || null;
 }
 
 function stringOrEmpty(value) {

package/lib/manual-apply-state.mjs

@@ -30,6 +30,21 @@ export function manualUnbookedEntryCount(preview) {
   return preview?.unbookedEntries?.length || 0;
 }
 
+export function buildManualDuplicateConfirmation(preview) {
+  const duplicates = (preview?.entries || []).filter((entry) => entry.possibleDuplicate);
+  const list = duplicates.map((entry) => {
+    const duplicate = entry.possibleDuplicate;
+    return duplicate.source === 'batch'
+      ? `${entry.id} repeats ${duplicate.entryId}`
+      : `${entry.id} matches RO logwork ${duplicate.logworkId ?? '(no id)'}`;
+  }).join(', ');
+  return `This preview contains ${duplicates.length} possible duplicate entries (${list}). Submit them anyway?`;
+}
+
+export function manualDuplicateEntryCount(preview) {
+  return (preview?.entries || []).filter((entry) => entry.possibleDuplicate).length;
+}
+
 export function totalPreviewHours(preview) {
   return (preview?.entries || []).reduce((sum, entry) => sum + Number(entry.hours || 0), 0);
 }

package/lib/manual-commands.mjs

@@ -74,8 +74,8 @@ export const MANUAL_COMMANDS = [
   },
   {
     name: '/map',
-    description: 'Map ticket prefix to projectMemberId',
-    usage: '/map SCB 5234',
+    description: 'Map ticket prefix or git repo to projectMemberId',
+    usage: '/map SCB 5234 | /map --repo [path] 5234',
     aliases: []
   }
 ];