logwork-cli 0.0.0-stage → 1.1.0

package/commands/setup.mjs

@@ -0,0 +1,508 @@
+import { constants as fsConstants, promises as fs } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { delimiter, dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { redactText } from '../lib/auth-redaction.mjs';
+import { credentialStoreLabel } from '../lib/credential-store.mjs';
+import { helperHome } from '../lib/paths.mjs';
+import {
+  MCP_SERVER_NAME,
+  defaultMcpServerPath,
+  formatCodexToml,
+  stdioMcpServersConfig,
+  vscodeMcpConfig
+} from '../lib/manual-mcp.mjs';
+import { loadReminderConfig } from '../lib/reminder-config.mjs';
+import { installReminderScheduler } from '../lib/reminder-scheduler.mjs';
+
+// Package name before the rename. Its global install provides a `logwork` bin
+// that would block `npm link` of logwork-cli, so setup removes it first.
+const LEGACY_PACKAGE_NAME = 'logwork-helper';
+const PACKAGE_NAMES = ['logwork-cli', LEGACY_PACKAGE_NAME];
+
+const EXCLUDED_DIRS = new Set([
+  '.git',
+  'node_modules'
+]);
+
+// `logwork setup`: copy this package into ~/.logwork-cli, install its
+// dependencies, link the `logwork` command, refresh a migrated reminder, and
+// print the MCP configs.
+export async function run(argv = []) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log(formatSetupHelp());
+    return 0;
+  }
+  const options = parseSetupUserArgs(argv);
+  const sourceDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+  const targetDir = helperHome();
+  await installUserRuntime({ options, sourceDir, targetDir });
+  return 0;
+}
+
+export function formatSetupHelp() {
+  return `Usage:
+  logwork setup [--login|--no-login]
+
+Installs the runtime to ~/.logwork-cli, links the \`logwork\` command, and prints
+MCP configs for Cursor, Antigravity, Claude Code, Codex and VS Code.
+Settings, mappings and the login session from an older logwork-helper install
+are carried over automatically.
+
+Options:
+  --login     Log in to Resource Optimiser after installing
+  --no-login  Do not ask to log in`;
+}
+
+export async function installUserRuntime({
+  options,
+  sourceDir,
+  targetDir,
+  mkdirFn = fs.mkdir,
+  copyFn = copyDirectory,
+  cleanupFn = sanitizeRuntimeMetadata,
+  installFn = installDependencies,
+  linkFn = linkGlobalBinaries,
+  authFn = maybeRunAuthLogin,
+  reminderFn = refreshReminderSchedule,
+  printFn = printMcpInstructions
+}) {
+  await mkdirFn(targetDir, { recursive: true });
+  if (resolve(sourceDir) !== resolve(targetDir)) {
+    await copyFn(sourceDir, targetDir, sourceDir);
+  }
+  const cleanupResult = await cleanupFn(targetDir);
+  await installFn(targetDir);
+  const linkResult = await linkFn(targetDir);
+  const authResult = await authFn(targetDir, options);
+  const reminderResult = await reminderFn(targetDir);
+  await printFn(targetDir, authResult, linkResult, cleanupResult, reminderResult);
+
+  return {
+    targetDir,
+    authResult,
+    linkResult,
+    cleanupResult,
+    reminderResult
+  };
+}
+
+// A reminder enabled by an older install still points at the old runtime.
+// Re-register it so the OS scheduler runs this runtime (and the legacy entry
+// is removed by installReminderScheduler).
+async function refreshReminderSchedule(targetDir) {
+  try {
+    const config = await loadReminderConfig();
+    if (!config?.enabled) {
+      return null;
+    }
+    await installReminderScheduler(config, { home: targetDir });
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+async function copyDirectory(sourceDir, targetDir, rootDir) {
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (EXCLUDED_DIRS.has(entry.name)) {
+      continue;
+    }
+
+    const sourcePath = join(sourceDir, entry.name);
+    const targetPath = join(targetDir, relative(rootDir, sourcePath));
+
+    if (entry.isDirectory()) {
+      await fs.mkdir(targetPath, { recursive: true });
+      await copyDirectory(sourcePath, targetDir, rootDir);
+      continue;
+    }
+
+    if (!entry.isFile() && !entry.isSymbolicLink()) {
+      continue;
+    }
+
+    await fs.mkdir(dirname(targetPath), { recursive: true });
+    await fs.copyFile(sourcePath, targetPath);
+  }
+}
+
+function installDependencies(targetDir) {
+  return resolveInstallArgs(targetDir)
+    .then((args) => runCommand('npm', args, {
+      cwd: targetDir,
+      stdio: 'inherit'
+    }));
+}
+
+function runCommand(command, args, options = {}) {
+  return new Promise((resolveValue, reject) => {
+    const child = spawn(command, args, options);
+
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolveValue();
+        return;
+      }
+
+      reject(new Error(`${command} ${args.join(' ')} failed with exit code ${code}.`));
+    });
+  });
+}
+
+async function resolveInstallArgs(targetDir) {
+  try {
+    await fs.access(join(targetDir, 'package-lock.json'));
+    return ['ci', '--omit=dev'];
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+    return ['install', '--omit=dev'];
+  }
+}
+
+export async function sanitizeRuntimeMetadata(targetDir, {
+  readFileFn = fs.readFile,
+  writeFileFn = fs.writeFile
+} = {}) {
+  const changes = [];
+  const packagePath = join(targetDir, 'package.json');
+  const packageLockPath = join(targetDir, 'package-lock.json');
+
+  await updateJsonFile(packagePath, {
+    readFileFn,
+    writeFileFn,
+    changes
+  }, (json) => {
+    for (const name of PACKAGE_NAMES) {
+      if (isStaleSelfDependency(json.dependencies?.[name])) {
+        delete json.dependencies[name];
+        changes.push(`package.json dependencies.${name}`);
+      }
+    }
+    return json;
+  });
+
+  await updateJsonFile(packageLockPath, {
+    readFileFn,
+    writeFileFn,
+    changes
+  }, (json) => {
+    for (const name of PACKAGE_NAMES) {
+      if (isStaleSelfDependency(json.packages?.['']?.dependencies?.[name])) {
+        delete json.packages[''].dependencies[name];
+        changes.push(`package-lock.json packages[""].dependencies.${name}`);
+      }
+      if (json.packages?.[`node_modules/${name}`]) {
+        delete json.packages[`node_modules/${name}`];
+        changes.push(`package-lock.json packages["node_modules/${name}"]`);
+      }
+      if (json.dependencies?.[`node_modules/${name}`]) {
+        delete json.dependencies[`node_modules/${name}`];
+        changes.push(`package-lock.json dependencies["node_modules/${name}"]`);
+      }
+      if (isStaleSelfDependency(json.dependencies?.[name]?.version)) {
+        delete json.dependencies[name];
+        changes.push(`package-lock.json dependencies.${name}`);
+      }
+    }
+    return json;
+  });
+
+  return {
+    changed: changes.length > 0,
+    changes
+  };
+}
+
+async function updateJsonFile(path, { readFileFn, writeFileFn }, update) {
+  let text;
+  try {
+    text = await readFileFn(path, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return;
+    }
+    throw error;
+  }
+
+  const json = JSON.parse(text);
+  const before = JSON.stringify(json);
+  const updated = update(json);
+  const after = JSON.stringify(updated);
+  if (before !== after) {
+    await writeFileFn(path, `${JSON.stringify(updated, null, 2)}\n`, 'utf8');
+  }
+}
+
+function isStaleSelfDependency(value) {
+  return typeof value === 'string' && /^file:.*logwork-(helper|cli).*\.tgz$/i.test(value);
+}
+
+export async function linkGlobalBinaries(targetDir, {
+  runner = runCommand,
+  commandFinder = findCommandOnPath
+} = {}) {
+  // Best effort: drop the pre-rename global package so its `logwork` bin does
+  // not block linking this one. A no-op when it is not installed.
+  await runner('npm', ['rm', '-g', LEGACY_PACKAGE_NAME], {
+    cwd: targetDir,
+    stdio: 'ignore'
+  }).catch(() => {});
+
+  try {
+    await runner('npm', ['link'], {
+      cwd: targetDir,
+      stdio: 'inherit'
+    });
+  } catch (error) {
+    return {
+      linked: false,
+      commandAvailable: false,
+      error: error.message
+    };
+  }
+
+  const commandAvailable = await commandFinder('logwork');
+  return {
+    linked: true,
+    commandAvailable,
+    warning: commandAvailable
+      ? null
+      : '`logwork` was linked, but it is not visible on PATH in this shell.'
+  };
+}
+
+export async function findCommandOnPath(commandName, {
+  platform = process.platform,
+  envPath = process.env.PATH || '',
+  accessFn = fs.access
+} = {}) {
+  const pathEntries = envPath.split(platform === 'win32' ? ';' : delimiter).filter(Boolean);
+  const names = platform === 'win32'
+    ? [commandName, `${commandName}.cmd`, `${commandName}.exe`, `${commandName}.bat`]
+    : [commandName];
+  for (const pathEntry of pathEntries) {
+    for (const name of names) {
+      const candidate = resolve(pathEntry, name);
+      try {
+        await accessFn(candidate, fsConstants.X_OK);
+        return true;
+      } catch {
+        // Keep searching PATH.
+      }
+    }
+  }
+
+  return false;
+}
+
+export function parseSetupUserArgs(args = []) {
+  let loginMode = 'prompt';
+
+  for (const arg of args) {
+    if (arg === '--login') {
+      loginMode = 'required';
+      continue;
+    }
+    if (arg === '--no-login') {
+      loginMode = 'skip';
+      continue;
+    }
+    throw new Error(`Unknown setup option: ${arg}`);
+  }
+
+  return { loginMode };
+}
+
+async function maybeRunAuthLogin(targetDir, { loginMode }) {
+  if (loginMode === 'skip') {
+    return null;
+  }
+
+  const shouldRun = loginMode === 'required' || await shouldPromptLogin();
+  if (!shouldRun) {
+    return null;
+  }
+
+  try {
+    await runAuthLogin(targetDir);
+    return { ok: true };
+  } catch (error) {
+    if (loginMode === 'required') {
+      throw error;
+    }
+    return {
+      ok: false,
+      error: error.message
+    };
+  }
+}
+
+async function shouldPromptLogin() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return false;
+  }
+
+  const { confirm, isCancel } = await import('@clack/prompts');
+  const { getStoredAuthStatus } = await import('../lib/auth.mjs');
+  const status = await getStoredAuthStatus().catch(() => ({ authenticated: false }));
+  if (status.authenticated) {
+    return false;
+  }
+
+  const answer = await confirm({
+    message: 'Log in to Resource Optimiser now?',
+    initialValue: true
+  });
+  if (isCancel(answer)) {
+    return false;
+  }
+
+  return Boolean(answer);
+}
+
+function runAuthLogin(targetDir) {
+  return new Promise((resolveValue, reject) => {
+    const child = spawn(process.execPath, [resolve(targetDir, 'bin', 'logwork.mjs'), 'login'], {
+      cwd: targetDir,
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        LOGWORK_HOME: targetDir
+      }
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolveValue();
+        return;
+      }
+      reject(new Error(`Resource Optimiser auth login failed with exit code ${code}.`));
+    });
+  });
+}
+
+function printMcpInstructions(targetDir, authResult = null, linkResult = null, cleanupResult = null, reminderResult = null) {
+  console.log(formatSetupUserInstructions({
+    targetDir,
+    authResult,
+    linkResult,
+    cleanupResult,
+    reminderResult
+  }));
+}
+
+export function formatSetupUserInstructions({
+  targetDir,
+  authResult = null,
+  linkResult = null,
+  cleanupResult = null,
+  reminderResult = null,
+  platform = process.platform
+} = {}) {
+  const entryPath = resolve(targetDir, 'bin', 'logwork.mjs');
+  const storeLabel = credentialStoreLabel({ platform });
+  const sections = [
+    `logwork-cli installed to ${targetDir}.`,
+    '',
+    'Install status',
+    `- Runtime: ${targetDir}`,
+    '- Dependencies: installed',
+    cleanupResult?.changed
+      ? '- Runtime metadata: removed stale local tarball dependency'
+      : '- Runtime metadata: ready',
+    `- Auth: ${formatAuthStatus(authResult)}`,
+    ...(reminderResult ? [`- Reminder: ${reminderResult.ok ? 're-registered for this runtime' : `not refreshed (${redactText(reminderResult.error || 'unknown error')}); run \`logwork reminder enable\``}`] : []),
+    '',
+    formatTerminalCommandInstructions(linkResult),
+    '',
+    'Next steps',
+    ...formatNextSteps(authResult),
+    '',
+    `MCP config (server name "${MCP_SERVER_NAME}", runs: node ${entryPath} mcp)`,
+    '',
+    'Cursor / Antigravity / Claude Code (.mcp.json):',
+    JSON.stringify(stdioMcpServersConfig(entryPath), null, 2),
+    '',
+    'Codex config.toml:',
+    formatCodexToml(entryPath),
+    '',
+    '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.',
+    '- An old "logwork-helper" MCP entry can be deleted; it points at the old runtime.',
+    '',
+    'Safety',
+    '- Do not paste passwords, 2FA codes, Bearer tokens, cookies, or raw curl auth logs into AI chat.',
+    `- MCP config only needs command and args; tokens stay in ${storeLabel}.`,
+    '- Project mappings are stored separately and never store Resource Optimiser tokens.'
+  ];
+
+  return sections.join('\n');
+}
+
+function formatAuthStatus(authResult) {
+  if (authResult?.ok) {
+    return 'completed';
+  }
+  if (authResult?.ok === false) {
+    return `not completed (${redactText(authResult.error || 'unknown error')})`;
+  }
+  return 'not run';
+}
+
+function formatNextSteps(authResult) {
+  const steps = [];
+  let index = 1;
+  if (!authResult?.ok) {
+    steps.push(`${index}. Log in to Resource Optimiser:`);
+    steps.push('   logwork login');
+    index += 1;
+  }
+  steps.push(`${index}. Paste one MCP config below into your IDE.`);
+  steps.push(`${index + 1}. Restart or reload your IDE MCP tools.`);
+  steps.push(`${index + 2}. Verify with: Check my logwork for this week.`);
+  return steps;
+}
+
+export function formatTerminalCommandInstructions(linkResult = null) {
+  const commands = [
+    'Terminal command installed:',
+    '  logwork            open the terminal UI',
+    '  logwork login      log in to Resource Optimiser',
+    '  logwork --help     list all commands'
+  ];
+
+  if (!linkResult || (linkResult.linked === true && linkResult.commandAvailable === true)) {
+    return commands.join('\n');
+  }
+
+  if (linkResult.linked === true && linkResult.commandAvailable === false) {
+    return [
+      ...commands,
+      '',
+      `Warning: ${linkResult.warning}`,
+      'If `logwork` is not found, open a new terminal or ensure npm global bin is on PATH.'
+    ].join('\n');
+  }
+
+  return [
+    'Terminal command link did not complete.',
+    `Reason: ${linkResult.error}`,
+    '',
+    'Fallback:',
+    '  npm install -g logwork-cli'
+  ].join('\n');
+}

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/commands/tui.mjs

@@ -0,0 +1,50 @@
+import { resolve } from 'node:path';
+import { runManualRepl } from '../lib/manual-repl.mjs';
+import { checkForUpdates, formatUpdateNotice } from '../lib/update-service.mjs';
+
+// `logwork` with no command: the Ink terminal UI.
+export async function run(argv = []) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log(formatTuiHelp());
+    return 0;
+  }
+  if (argv.length) {
+    throw new Error(`Unknown option: ${argv[0]}. Run \`logwork --help\` for commands.`);
+  }
+
+  const updateNotice = process.stdin.isTTY && process.stdout.isTTY
+    ? await getStartupUpdateNotice()
+    : '';
+  await runManualRepl({
+    cwd: resolve(process.cwd()),
+    updateNotice
+  });
+  return undefined;
+}
+
+export async function getStartupUpdateNotice({ checkForUpdatesFn = checkForUpdates } = {}) {
+  try {
+    return formatUpdateNotice(await checkForUpdatesFn());
+  } catch {
+    return '';
+  }
+}
+
+export function formatTuiHelp() {
+  return `Usage:
+  logwork
+
+Opens the terminal UI. Type / for live command suggestions, Esc to exit.
+
+Common commands inside the UI:
+  /query this-week          Booked vs logged hours with entry ids
+  /logwork                  Paste or write a weekly block, preview, then apply
+  /edit-logwork 304032 --task Bug Fix --desc Fix date picker (SAP-42)
+  /reconcile this-week      Compare RO and Jira
+  /projects                 List RO projects
+  /map SCB 5234             Map a ticket prefix to a project
+  /mcp                      Show MCP config for an IDE
+  /history                  Local apply history
+
+Run \`logwork --help\` for the CLI commands.`;
+}