@gitpm/cli 0.1.0

package/src/commands/sync.ts

@@ -0,0 +1,238 @@
+import {
+  loadConfig as loadGitHubConfig,
+  syncWithGitHub,
+} from '@gitpm/sync-github';
+import type { ConflictStrategy } from '@gitpm/sync-github';
+import {
+  loadConfig as loadGitLabConfig,
+  syncWithGitLab,
+} from '@gitpm/sync-gitlab';
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import ora from 'ora';
+import { resolveToken } from '../utils/auth.js';
+import { resolveMetaDir } from '../utils/config.js';
+import { promptConflictResolution } from '../utils/conflict-ui.js';
+import { printError, printSuccess } from '../utils/output.js';
+
+export const syncCommand = new Command('sync')
+  .description('Bidirectional sync between local .meta/ and GitHub/GitLab')
+  .option('--token <token>', 'Personal access token')
+  .option(
+    '--strategy <strategy>',
+    'Conflict resolution strategy (local-wins, remote-wins, ask)',
+    'ask',
+  )
+  .option('--dry-run', 'Preview changes without syncing')
+  .option('--yes', 'Skip confirmation prompt')
+  .action(async (opts, cmd) => {
+    const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+    const strategy = opts.strategy as ConflictStrategy;
+
+    // Detect platform
+    const ghConfig = await loadGitHubConfig(metaDir);
+    const glConfig = await loadGitLabConfig(metaDir);
+
+    if (glConfig.ok) {
+      await syncGitLab(opts, metaDir, glConfig.value, strategy);
+    } else if (ghConfig.ok) {
+      await syncGitHub(opts, metaDir, ghConfig.value.repo, strategy);
+    } else {
+      printError(
+        'No sync config found. Run `gitpm import` first to set up sync.',
+      );
+      process.exit(1);
+    }
+  });
+
+async function syncGitHub(
+  opts: Record<string, string | boolean | undefined>,
+  metaDir: string,
+  repo: string,
+  strategy: ConflictStrategy,
+): Promise<void> {
+  let token: string;
+  try {
+    token = await resolveToken(opts.token as string | undefined);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : 'Failed to resolve token.');
+    process.exit(1);
+  }
+
+  if (opts.dryRun) {
+    const spinner = ora('Calculating sync changes...').start();
+    const result = await syncWithGitHub({
+      token,
+      repo,
+      metaDir,
+      strategy,
+      dryRun: true,
+    });
+
+    if (!result.ok) {
+      spinner.fail('Dry run failed.');
+      printError(result.error.message);
+      process.exit(1);
+    }
+
+    spinner.succeed('Dry run complete.');
+    printSyncSummary(result.value, 'GitHub');
+    return;
+  }
+
+  if (!opts.yes) {
+    const confirmed = await confirm({
+      message: 'Run bidirectional sync with GitHub?',
+      default: true,
+    });
+    if (!confirmed) {
+      console.log(chalk.dim('Sync cancelled.'));
+      return;
+    }
+  }
+
+  const spinner = ora('Syncing with GitHub...').start();
+  const result = await syncWithGitHub({
+    token,
+    repo,
+    metaDir,
+    strategy: strategy === 'ask' ? 'ask' : strategy,
+  });
+
+  if (!result.ok) {
+    spinner.fail('Sync failed.');
+    printError(result.error.message);
+    process.exit(1);
+  }
+
+  spinner.succeed('Sync complete.');
+  await handleConflicts(result.value, strategy);
+  printSyncSummary(result.value, 'GitHub');
+}
+
+async function syncGitLab(
+  opts: Record<string, string | boolean | undefined>,
+  metaDir: string,
+  config: { project: string; project_id: number; base_url: string },
+  strategy: ConflictStrategy,
+): Promise<void> {
+  const token = (opts.token as string | undefined) ?? process.env.GITLAB_TOKEN;
+  if (!token) {
+    printError(
+      'No GitLab token found. Provide via --token flag or GITLAB_TOKEN env var.',
+    );
+    process.exit(1);
+  }
+
+  if (opts.dryRun) {
+    const spinner = ora('Calculating sync changes...').start();
+    const result = await syncWithGitLab({
+      token,
+      project: config.project,
+      projectId: config.project_id,
+      baseUrl: config.base_url,
+      metaDir,
+      strategy,
+      dryRun: true,
+    });
+
+    if (!result.ok) {
+      spinner.fail('Dry run failed.');
+      printError(result.error.message);
+      process.exit(1);
+    }
+
+    spinner.succeed('Dry run complete.');
+    printSyncSummary(result.value, 'GitLab');
+    return;
+  }
+
+  if (!opts.yes) {
+    const confirmed = await confirm({
+      message: 'Run bidirectional sync with GitLab?',
+      default: true,
+    });
+    if (!confirmed) {
+      console.log(chalk.dim('Sync cancelled.'));
+      return;
+    }
+  }
+
+  const spinner = ora('Syncing with GitLab...').start();
+  const result = await syncWithGitLab({
+    token,
+    project: config.project,
+    projectId: config.project_id,
+    baseUrl: config.base_url,
+    metaDir,
+    strategy: strategy === 'ask' ? 'ask' : strategy,
+  });
+
+  if (!result.ok) {
+    spinner.fail('Sync failed.');
+    printError(result.error.message);
+    process.exit(1);
+  }
+
+  spinner.succeed('Sync complete.');
+  await handleConflicts(result.value, strategy);
+  printSyncSummary(result.value, 'GitLab');
+}
+
+async function handleConflicts(
+  result: {
+    conflicts: unknown[];
+  },
+  strategy: ConflictStrategy,
+): Promise<void> {
+  const { conflicts } = result;
+  if (strategy === 'ask' && conflicts.length > 0) {
+    console.log();
+    console.log(
+      chalk.yellow(`${conflicts.length} conflict(s) require resolution:`),
+    );
+    const resolutions = await promptConflictResolution(
+      conflicts as Parameters<typeof promptConflictResolution>[0],
+    );
+    console.log(
+      chalk.dim(
+        `Resolved ${resolutions.length}, skipped ${conflicts.length - resolutions.length}`,
+      ),
+    );
+  }
+}
+
+function printSyncSummary(
+  result: {
+    pushed: { milestones: number; issues: number };
+    pulled: { milestones: number; issues: number };
+    conflicts: unknown[];
+    resolved: number;
+    skipped: number;
+  },
+  platform: string,
+): void {
+  const pushedTotal = result.pushed.milestones + result.pushed.issues;
+  const pulledTotal = result.pulled.milestones + result.pulled.issues;
+
+  console.log();
+  console.log(chalk.bold('┌──────────────────────────────────────┐'));
+  console.log(chalk.bold('│           Sync Complete              │'));
+  console.log(chalk.bold('├──────────────────┬───────────────────┤'));
+  console.log(
+    `${chalk.bold('│')} Pushed to ${platform.padEnd(6)} │ ${String(pushedTotal).padEnd(17)} ${chalk.bold('│')}`,
+  );
+  console.log(
+    `${chalk.bold('│')} Pulled to local  │ ${String(pulledTotal).padEnd(17)} ${chalk.bold('│')}`,
+  );
+  console.log(
+    `${chalk.bold('│')} Conflicts        │ ${String(`${result.resolved} resolved`).padEnd(17)} ${chalk.bold('│')}`,
+  );
+  console.log(
+    `${chalk.bold('│')} Errors           │ ${String(result.skipped).padEnd(17)} ${chalk.bold('│')}`,
+  );
+  console.log(chalk.bold('└──────────────────┴───────────────────┘'));
+  console.log();
+  printSuccess('Sync complete.');
+}

package/src/commands/validate.ts

@@ -0,0 +1,79 @@
+import { relative } from 'node:path';
+import { parseTree, resolveRefs, validateTree } from '@gitpm/core';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { resolveMetaDir } from '../utils/config.js';
+import { printError, printSuccess, printWarning } from '../utils/output.js';
+
+export const validateCommand = new Command('validate')
+  .description('Validate the .meta/ project tree')
+  .action(async (_opts, cmd) => {
+    const metaDir = resolveMetaDir(cmd.optsWithGlobals().metaDir);
+
+    // Parse tree
+    const parseResult = await parseTree(metaDir);
+    if (!parseResult.ok) {
+      printError(parseResult.error.message);
+      process.exit(1);
+    }
+
+    const tree = parseResult.value;
+
+    // Check for parse errors
+    if (tree.errors.length > 0) {
+      for (const err of tree.errors) {
+        const rel = relative(process.cwd(), err.filePath);
+        console.log(chalk.red(`  ✗ ${rel}: ${err.message}`));
+      }
+    }
+
+    // Resolve refs
+    const resolveResult = resolveRefs(tree);
+    if (!resolveResult.ok) {
+      printError(resolveResult.error.message);
+      process.exit(1);
+    }
+
+    // Validate
+    const result = validateTree(resolveResult.value);
+
+    // Print validation errors
+    for (const err of result.errors) {
+      const rel = err.filePath ? relative(process.cwd(), err.filePath) : '';
+      const location = rel ? `${rel}: ` : '';
+      const id = err.entityId ? `[${err.entityId}] ` : '';
+      console.log(chalk.red(`  ✗ ${location}${id}${err.code}: ${err.message}`));
+    }
+
+    // Print validation warnings
+    for (const warn of result.warnings) {
+      const rel = warn.filePath ? relative(process.cwd(), warn.filePath) : '';
+      const location = rel ? `${rel}: ` : '';
+      const id = warn.entityId ? `[${warn.entityId}] ` : '';
+      console.log(
+        chalk.yellow(`  ⚠ ${location}${id}${warn.code}: ${warn.message}`),
+      );
+    }
+
+    if (!result.valid) {
+      console.log();
+      printError(
+        `Validation failed with ${result.errors.length} error(s) and ${result.warnings.length} warning(s)`,
+      );
+      process.exit(1);
+    }
+
+    const entityCount =
+      tree.stories.length +
+      tree.epics.length +
+      tree.milestones.length +
+      tree.roadmaps.length +
+      tree.prds.length;
+
+    if (result.warnings.length > 0) {
+      console.log();
+      printWarning(`${result.warnings.length} warning(s)`);
+    }
+
+    printSuccess(`.meta/ tree is valid (${entityCount} entities)`);
+  });

package/src/index.ts

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import { importCommand } from './commands/import.js';
+import { initCommand } from './commands/init.js';
+import { pullCommand } from './commands/pull.js';
+import { pushCommand } from './commands/push.js';
+import { syncCommand } from './commands/sync.js';
+import { validateCommand } from './commands/validate.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(
+  readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'),
+);
+
+const program = new Command();
+
+program
+  .name('gitpm')
+  .description('Git-native project management')
+  .version(pkg.version)
+  .option('--meta-dir <path>', 'Path to .meta directory', '.meta')
+  .option('--token <token>', 'Personal access token (GitHub or GitLab)');
+
+program.addCommand(initCommand);
+program.addCommand(validateCommand);
+program.addCommand(importCommand);
+program.addCommand(pushCommand);
+program.addCommand(pullCommand);
+program.addCommand(syncCommand);
+
+program.parse();

package/src/utils/auth.ts

@@ -0,0 +1,28 @@
+import { execSync } from 'node:child_process';
+
+/**
+ * Resolve a GitHub token from multiple sources in priority order:
+ * 1. Explicit CLI --token flag
+ * 2. GITHUB_TOKEN environment variable
+ * 3. GitHub CLI (`gh auth token`)
+ */
+export async function resolveToken(cliToken?: string): Promise<string> {
+  if (cliToken) return cliToken;
+
+  const envToken = process.env.GITHUB_TOKEN;
+  if (envToken) return envToken;
+
+  try {
+    const ghToken = execSync('gh auth token', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    if (ghToken) return ghToken;
+  } catch {
+    // gh CLI not installed or not authenticated — fall through
+  }
+
+  throw new Error(
+    "No GitHub token found. Provide via --token flag, GITHUB_TOKEN env var, or install GitHub CLI (gh) and run 'gh auth login'.",
+  );
+}

package/src/utils/config.ts

@@ -0,0 +1,5 @@
+import { resolve } from 'node:path';
+
+export function resolveMetaDir(metaDirOption: string): string {
+  return resolve(process.cwd(), metaDirOption);
+}

package/src/utils/conflict-ui.ts

@@ -0,0 +1,45 @@
+import type { FieldConflict, Resolution } from '@gitpm/sync-github';
+import { select } from '@inquirer/prompts';
+import chalk from 'chalk';
+
+/**
+ * Interactively prompt the user to resolve each conflict.
+ */
+export async function promptConflictResolution(
+  conflicts: FieldConflict[],
+): Promise<Resolution[]> {
+  const resolutions: Resolution[] = [];
+
+  for (const conflict of conflicts) {
+    console.log();
+    console.log(chalk.yellow('━━━ CONFLICT ━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(
+      `Entity: ${chalk.bold(`"${conflict.entityTitle}"`)} (${conflict.entityId})`,
+    );
+    console.log(`Type:   ${conflict.entityType}`);
+    console.log(`Field:  ${conflict.field}`);
+    console.log();
+    console.log(`  Local:  ${chalk.green(String(conflict.localValue))}`);
+    console.log(`  Remote: ${chalk.blue(String(conflict.remoteValue))}`);
+    console.log(chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+
+    const pick = await select({
+      message: 'How do you want to resolve this conflict?',
+      choices: [
+        { name: '[l] Keep local', value: 'local' as const },
+        { name: '[r] Keep remote', value: 'remote' as const },
+        { name: '[s] Skip (leave unresolved)', value: 'skip' as const },
+      ],
+    });
+
+    if (pick !== 'skip') {
+      resolutions.push({
+        entityId: conflict.entityId,
+        field: conflict.field,
+        pick,
+      });
+    }
+  }
+
+  return resolutions;
+}

package/src/utils/output.ts

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+
+export function printSuccess(msg: string): void {
+  console.log(chalk.green(`✓ ${msg}`));
+}
+
+export function printError(msg: string): void {
+  console.error(chalk.red(`✗ ${msg}`));
+}
+
+export function printWarning(msg: string): void {
+  console.warn(chalk.yellow(`⚠ ${msg}`));
+}
+
+export function printTree(files: string[]): void {
+  for (const file of files) {
+    const parts = file.split('/');
+    const indent = '  '.repeat(parts.length - 1);
+    const name = parts[parts.length - 1];
+    const isDir = !name.includes('.');
+    console.log(`${indent}${isDir ? chalk.blue(`${name}/`) : name}`);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: false,
+  clean: true,
+  banner: {
+    js: '#!/usr/bin/env node',
+  },
+});