logwork-cli 0.0.0-stage → 1.1.0

package/lib/logwork-config.mjs

@@ -0,0 +1,199 @@
+import { promises as fs } from 'node:fs';
+import {
+  legacyUserConfigPath,
+  projectConfigPath,
+  userConfigPath
+} from './paths.mjs';
+import { atomicWriteFile } from './atomic-file.mjs';
+import { withFileLock } from './file-lock.mjs';
+import {
+  normalizeProjectName,
+  sameProjectIdentity
+} from './project-identity.mjs';
+import { safeJsonParse } from './util.mjs';
+
+export async function loadLocalConfig(cwd = process.cwd()) {
+  const legacyConfig = normalizeConfig(await readRawConfigPath(legacyUserConfigPath()));
+  const userConfig = normalizeConfig(await readRawConfigPath(userConfigPath()));
+  const projectPath = projectConfigPath(cwd);
+  const projectConfig = projectPath === userConfigPath()
+    ? normalizeConfig({})
+    : normalizeConfig(await readRawConfigPath(projectPath));
+
+  return mergeConfigs(legacyConfig, userConfig, projectConfig);
+}
+
+export async function upsertProjectMappingConfig({
+  cwd = process.cwd(),
+  scope = 'user',
+  project,
+  tickets = [],
+  keywords = [],
+  lockOptions = {}
+}) {
+  const path = scope === 'project' ? projectConfigPath(cwd) : userConfigPath();
+  return withFileLock(path, async () => {
+    const config = scope === 'project'
+      ? normalizeConfig(await readRawConfigPath(path))
+      : mergeConfigs(
+        normalizeConfig(await readRawConfigPath(legacyUserConfigPath())),
+        normalizeConfig(await readRawConfigPath(path))
+      );
+    const mapping = {
+      projectName: project.projectName,
+      projectMemberId: project.projectMemberId,
+      tickets: normalizeTickets(tickets),
+      keywords: normalizeKeywords(keywords)
+    };
+    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])
+      };
+    } else {
+      projectMappings.push(mapping);
+    }
+
+    const nextConfig = { projectMappings };
+    await atomicWriteFile(path, `${JSON.stringify(nextConfig, null, 2)}\n`);
+
+    return {
+      path,
+      scope,
+      config: normalizeConfig(nextConfig),
+      mapping: normalizeConfig({ projectMappings: [existingIndex >= 0 ? projectMappings[existingIndex] : mapping] }).projectMappings[0],
+      created: existingIndex < 0
+    };
+  }, lockOptions);
+}
+
+export function normalizeConfig(config) {
+  const rawMappings = Array.isArray(config.projectMappings)
+    ? config.projectMappings
+    : Array.isArray(config.mappings)
+      ? config.mappings
+      : [];
+
+  return {
+    projectMappings: rawMappings
+      .filter((mapping) => mapping && typeof mapping === 'object')
+      .map(normalizeMapping)
+      .filter((mapping) => mapping.projectMemberId !== undefined || mapping.projectName)
+  };
+}
+
+export function configPath(cwd = process.cwd(), scope = 'user') {
+  return scope === 'project' ? projectConfigPath(cwd) : userConfigPath();
+}
+
+async function readRawConfigPath(path) {
+  try {
+    const text = await fs.readFile(path, 'utf8');
+    const data = safeJsonParse(text, null);
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+      throw new Error(`${path} must contain a JSON object.`);
+    }
+    return data;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {};
+    }
+    throw error;
+  }
+}
+
+function mergeConfigs(...configs) {
+  const mappings = new Map();
+
+  for (const config of configs) {
+    for (const mapping of config.projectMappings) {
+      const key = mappingKey(mapping);
+      const existing = mappings.get(key);
+      mappings.set(key, existing ? mergeMapping(existing, mapping) : mapping);
+    }
+  }
+
+  return {
+    projectMappings: [...mappings.values()]
+  };
+}
+
+function mappingKey(mapping) {
+  return mapping.projectMemberId !== undefined && mapping.projectMemberId !== null
+    ? `member:${mapping.projectMemberId}`
+    : `name:${normalizeProjectName(mapping.projectName)}`;
+}
+
+function normalizeMapping(mapping) {
+  return {
+    projectName: stringOrEmpty(mapping.projectName),
+    projectMemberId: optionalId(mapping.projectMemberId),
+    tickets: normalizeTickets(mapping.tickets),
+    keywords: normalizeKeywords(mapping.keywords)
+  };
+}
+
+function mergeMapping(existing, next) {
+  return {
+    projectName: next.projectName || existing.projectName,
+    projectMemberId: next.projectMemberId ?? existing.projectMemberId,
+    tickets: uniqueStrings([...existing.tickets, ...next.tickets], { uppercase: true }),
+    keywords: uniqueStrings([...existing.keywords, ...next.keywords])
+  };
+}
+
+function stringOrEmpty(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function optionalId(value) {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : undefined;
+  }
+
+  const text = String(value).trim();
+  return text ? text : undefined;
+}
+
+function stringArray(value) {
+  return Array.isArray(value)
+    ? value.filter((item) => typeof item === 'string').map((item) => item.trim()).filter(Boolean)
+    : [];
+}
+
+function normalizeTickets(value) {
+  return uniqueStrings(stringArray(value), { uppercase: true });
+}
+
+function normalizeKeywords(value) {
+  return uniqueStrings(stringArray(value));
+}
+
+function uniqueStrings(values, { uppercase = false } = {}) {
+  const seen = new Set();
+  const results = [];
+
+  for (const value of values) {
+    const normalized = uppercase ? value.toUpperCase() : value.trim();
+    const key = normalized.toLowerCase();
+    if (!normalized || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    results.push(normalized);
+  }
+
+  return results;
+}

package/lib/logwork-f03-enrich.mjs

@@ -0,0 +1,41 @@
+export async function enrichEntriesWithLogworkF03(entries, { dates = [], fetchLogworkDay } = {}) {
+  if (!fetchLogworkDay || !entries?.length || !dates?.length) {
+    return { entries, f03ByDate: {} };
+  }
+
+  const f03ByDate = {};
+  const statusById = new Map();
+
+  for (const date of [...new Set(dates.filter(Boolean))]) {
+    const day = await fetchLogworkDay(date);
+    f03ByDate[date] = {
+      isLocked: day.isLocked,
+      entryCount: day.entries?.length || 0
+    };
+    for (const entry of day.entries || []) {
+      if (entry.id !== undefined && entry.id !== null) {
+        statusById.set(String(entry.id), entry);
+      }
+    }
+  }
+
+  const enriched = entries.map((entry) => {
+    const f03 = entry.id !== undefined && entry.id !== null
+      ? statusById.get(String(entry.id))
+      : null;
+    if (!f03) {
+      return entry;
+    }
+    return {
+      ...entry,
+      status: f03.status || entry.status || '',
+      typeOfWork: f03.typeOfWork || entry.typeOfWork || '',
+      worklogTaskId: f03.worklogTaskId ?? entry.worklogTaskId ?? null,
+      description: f03.description || entry.description || '',
+      rejectionComment: f03.rejectionComment || entry.rejectionComment || '',
+      noteToPm: f03.noteToPm || entry.noteToPm || ''
+    };
+  });
+
+  return { entries: enriched, f03ByDate };
+}

package/lib/macos.mjs

@@ -0,0 +1,33 @@
+import { spawn } from 'node:child_process';
+
+export async function runOsascript(script, args = []) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('/usr/bin/osascript', ['-e', script, ...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) {
+        resolve(stdout.trim());
+        return;
+      }
+
+      const error = new Error(`osascript failed with exit code ${code}: ${stderr.trim() || 'no stderr'}`);
+      error.code = code;
+      error.stderr = stderr;
+      reject(error);
+    });
+  });
+}

package/lib/manual-apply-state.mjs

@@ -0,0 +1,35 @@
+import { formatHours } from './manual-logwork-wizard.mjs';
+
+export function getManualApplyBlocker(preview) {
+  if (!preview) {
+    return 'No preview available. Run /logwork first.';
+  }
+
+  if (preview.errors?.length) {
+    return 'Cannot apply preview with parse errors. Run /logwork again after fixing the text.';
+  }
+
+  if (preview.unresolvedEntries?.length) {
+    return `Cannot apply preview with ${preview.unresolvedEntries.length} unresolved entries. Use /projects and /map, then /logwork again.`;
+  }
+
+  return null;
+}
+
+export function buildManualApplyConfirmation(preview) {
+  const totalHours = totalPreviewHours(preview);
+  const entryCount = preview?.entries?.length || 0;
+  return `Apply ${entryCount} logwork entries totaling ${formatHours(totalHours)}h?`;
+}
+
+export function buildManualUnbookedConfirmation(preview) {
+  return `This preview contains ${manualUnbookedEntryCount(preview)} unbooked entries. Submit them anyway?`;
+}
+
+export function manualUnbookedEntryCount(preview) {
+  return preview?.unbookedEntries?.length || 0;
+}
+
+export function totalPreviewHours(preview) {
+  return (preview?.entries || []).reduce((sum, entry) => sum + Number(entry.hours || 0), 0);
+}

package/lib/manual-commands.mjs

@@ -0,0 +1,294 @@
+export const MANUAL_COMMANDS = [
+  {
+    name: '/help',
+    description: 'Show this help',
+    usage: '/help',
+    aliases: []
+  },
+  {
+    name: '/auth',
+    description: 'Authenticate Resource Optimiser or show Jira login command',
+    usage: '/auth [ro|jira]',
+    aliases: []
+  },
+  {
+    name: '/status',
+    description: 'Show Resource Optimiser and Jira auth status',
+    usage: '/status [ro|jira]',
+    aliases: []
+  },
+  {
+    name: '/diagnostics',
+    description: 'Write a sanitized support report',
+    usage: '/diagnostics',
+    aliases: []
+  },
+  {
+    name: '/history',
+    description: 'Show recent RO/Jira apply results',
+    usage: '/history [ro|jira|both]',
+    aliases: []
+  },
+  {
+    name: '/query',
+    description: 'Query logwork by preset period',
+    usage: '/query today | yesterday | this-week | last-week | this-month | last-month',
+    aliases: []
+  },
+  {
+    name: '/reconcile',
+    description: 'Compare Resource Optimiser and Jira worklogs',
+    usage: '/reconcile [today|yesterday|this-week|last-week|this-month|last-month]',
+    aliases: []
+  },
+  {
+    name: '/logwork',
+    description: 'Create Resource Optimiser, Jira, or combined logwork',
+    usage: '/logwork [ro|jira|both]',
+    aliases: []
+  },
+  {
+    name: '/mcp',
+    description: 'Show copy-ready MCP setup for an IDE',
+    usage: '/mcp [cursor|antigravity|copilot|claude-code|codex]',
+    aliases: []
+  },
+  {
+    name: '/edit-logwork',
+    description: 'Edit hours, worklog task, description, or type on existing RO logwork (replaces the entry)',
+    usage: '/edit-logwork <id> --hours <h> [--task-name <task>] [--description <text>] [--type <type>]',
+    aliases: []
+  },
+  {
+    name: '/apply',
+    description: 'Apply the last preview after confirmation',
+    usage: '/apply',
+    aliases: [],
+    hidden: true
+  },
+  {
+    name: '/projects',
+    description: 'List projects with weekly booked/logged chart',
+    usage: '/projects [projectMemberId|projectId|name]',
+    aliases: []
+  },
+  {
+    name: '/map',
+    description: 'Map ticket prefix to projectMemberId',
+    usage: '/map SCB 5234',
+    aliases: []
+  }
+];
+
+export const TASK_COMMANDS = [
+  {
+    name: '/save',
+    description: 'Save this draft locally',
+    usage: '/save',
+    aliases: []
+  },
+  {
+    name: '/drafts',
+    description: 'Resume or delete saved drafts',
+    usage: '/drafts',
+    aliases: []
+  },
+  {
+    name: '/diagnostics',
+    description: 'Write a sanitized support report',
+    usage: '/diagnostics',
+    aliases: []
+  },
+  {
+    name: '/remove',
+    description: 'Select tasks to delete',
+    usage: '/remove',
+    aliases: []
+  },
+  {
+    name: '/edit',
+    description: 'Select one task and replace it',
+    usage: '/edit',
+    aliases: []
+  },
+  {
+    name: '/clear',
+    description: 'Clear current task list',
+    usage: '/clear',
+    aliases: []
+  },
+  {
+    name: '/back',
+    description: 'Return to project picker',
+    usage: '/back',
+    aliases: []
+  },
+  {
+    name: '/cancel',
+    description: 'Discard this logwork session',
+    usage: '/cancel',
+    aliases: ['/discard']
+  }
+];
+
+export const QUERY_PERIOD_COMMANDS = [
+  {
+    name: '/query today',
+    description: 'Query today',
+    aliases: []
+  },
+  {
+    name: '/query yesterday',
+    description: 'Query yesterday',
+    aliases: []
+  },
+  {
+    name: '/query this-week',
+    description: 'Query this week',
+    aliases: []
+  },
+  {
+    name: '/query last-week',
+    description: 'Query last week',
+    aliases: []
+  },
+  {
+    name: '/query this-month',
+    description: 'Query this month',
+    aliases: []
+  },
+  {
+    name: '/query last-month',
+    description: 'Query last month',
+    aliases: []
+  }
+];
+
+export const RECONCILE_PERIOD_COMMANDS = QUERY_PERIOD_COMMANDS.map((command) => ({
+  ...command,
+  name: command.name.replace('/query', '/reconcile'),
+  description: command.description.replace('Query', 'Reconcile')
+}));
+
+export const LOGWORK_TARGET_COMMANDS = [
+  {
+    name: '/logwork ro',
+    description: 'Create Resource Optimiser logwork',
+    aliases: []
+  },
+  {
+    name: '/logwork jira',
+    description: 'Create Jira worklogs',
+    aliases: []
+  },
+  {
+    name: '/logwork both',
+    description: 'Create RO and Jira previews',
+    aliases: []
+  }
+];
+
+export const COMMAND_SUGGESTION_LIMIT = 9;
+
+export function formatManualHelp(commands = MANUAL_COMMANDS) {
+  const visibleCommands = commands.filter((command) => command.hidden !== true);
+  return [
+    'Commands:',
+    ...visibleCommands.map((command) => `  ${command.usage.padEnd(36)} ${command.description}`)
+  ].join('\n');
+}
+
+export function findManualCommand(name, commands = MANUAL_COMMANDS) {
+  const normalized = String(name || '').toLowerCase();
+  return commands.find((command) => (
+    command.name === normalized ||
+    command.aliases.includes(normalized)
+  ));
+}
+
+export function getCommandSuggestions(buffer, commands = MANUAL_COMMANDS) {
+  const value = String(buffer || '');
+  if (!value.startsWith('/')) {
+    return [];
+  }
+
+  const queryPeriodSuggestions = getQueryPeriodSuggestions(value, commands);
+  if (queryPeriodSuggestions.length) {
+    return queryPeriodSuggestions;
+  }
+
+  const reconciliationPeriodSuggestions = getReconciliationPeriodSuggestions(value, commands);
+  if (reconciliationPeriodSuggestions.length) {
+    return reconciliationPeriodSuggestions;
+  }
+
+  const logworkTargetSuggestions = getLogworkTargetSuggestions(value, commands);
+  if (logworkTargetSuggestions.length) {
+    return logworkTargetSuggestions;
+  }
+
+  if (/^\S+\s/.test(value)) {
+    return [];
+  }
+
+  const commandPart = value.split(/\s+/, 1)[0].toLowerCase();
+  if (!commandPart) {
+    return [];
+  }
+
+  return commands.filter((command) => command.hidden !== true && command.name.startsWith(commandPart));
+}
+
+function getQueryPeriodSuggestions(value, commands) {
+  if (commands !== MANUAL_COMMANDS) {
+    return [];
+  }
+
+  const normalized = value.toLowerCase();
+  if (normalized !== '/query' && !normalized.startsWith('/query ')) {
+    return [];
+  }
+
+  return QUERY_PERIOD_COMMANDS.filter((command) => command.name.startsWith(normalized));
+}
+
+function getReconciliationPeriodSuggestions(value, commands) {
+  if (commands !== MANUAL_COMMANDS) {
+    return [];
+  }
+
+  const normalized = value.toLowerCase();
+  if (normalized !== '/reconcile' && !normalized.startsWith('/reconcile ')) {
+    return [];
+  }
+
+  return RECONCILE_PERIOD_COMMANDS.filter((command) => command.name.startsWith(normalized));
+}
+
+function getLogworkTargetSuggestions(value, commands) {
+  if (commands !== MANUAL_COMMANDS) {
+    return [];
+  }
+
+  const normalized = value.toLowerCase();
+  if (!normalized.startsWith('/logwork ')) {
+    return [];
+  }
+
+  return LOGWORK_TARGET_COMMANDS.filter((command) => command.name.startsWith(normalized));
+}
+
+export function renderCommandSuggestions(buffer, selectedIndex = 0, commands = MANUAL_COMMANDS) {
+  const suggestions = getCommandSuggestions(buffer, commands);
+  if (!suggestions.length) {
+    return '';
+  }
+
+  return suggestions
+    .slice(0, COMMAND_SUGGESTION_LIMIT)
+    .map((command, index) => {
+      const marker = index === selectedIndex ? '›' : ' ';
+      return `${marker} ${command.name.padEnd(12)} ${command.description}`;
+    })
+    .join('\n');
+}