@nemus-cli/nemus 0.9.0 → 0.11.0

package/src/commands/prune.ts

@@ -0,0 +1,183 @@
+import { Command } from 'commander';
+import * as fs from 'fs/promises';
+import { safeWorkspacePath } from '../utils/validation';
+import { listWorkspaces } from '../utils/workspace-meta';
+import { getWorkspaceSessions } from '../utils/claude-sessions';
+import { getAllReposStatus } from '../utils/git-status';
+import { logInfo, logSuccess, logError, logWarning, logStep } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { confirm } from '../utils/prompt';
+import { getGlobalOpts } from '../utils/command-helpers';
+import { outputJson, outputJsonError } from '../utils/output';
+import {
+  toCandidate,
+  isStale,
+  planPrune,
+  type WorkspaceForPrune,
+  type PruneCandidate,
+} from '../utils/prune';
+
+const DEFAULT_DAYS = 30;
+
+export function registerPruneCommand(parent: Command) {
+  parent
+    .command('prune')
+    .description('Delete workspaces with no recent activity (safe by default)')
+    .option('-d, --days <n>', `Consider a workspace stale after N days of inactivity (default ${DEFAULT_DAYS})`)
+    .option('--include-dirty', 'Also prune workspaces with uncommitted/unpushed changes (default: protected)')
+    .option('--dry-run', 'Show what would be pruned without deleting anything')
+    .option('-y, --yes', 'Skip the confirmation prompt')
+    .option('--json', 'Output the prune plan as JSON (never deletes)')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      await handlePrune({ ...opts, ...globalOpts });
+    });
+}
+
+function parseDays(raw: unknown): number | null {
+  if (raw === undefined) return DEFAULT_DAYS;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) return null;
+  return Math.floor(n);
+}
+
+export async function handlePrune(opts: {
+  days?: string;
+  includeDirty?: boolean;
+  dryRun?: boolean;
+  yes?: boolean;
+  json?: boolean;
+}) {
+  const json = !!opts.json;
+  const days = parseDays(opts.days);
+  if (days === null) {
+    if (json) outputJsonError('--days must be a non-negative number');
+    else logError('--days must be a non-negative number');
+    process.exit(1);
+  }
+
+  try {
+    const [workspaces, sessions] = await Promise.all([listWorkspaces(), getWorkspaceSessions()]);
+    const sessionMap = new Map(sessions.map((s) => [s.workspaceName, s]));
+    const now = Date.now();
+
+    const candidates: PruneCandidate[] = workspaces.map((ws) => {
+      const session = sessionMap.get(ws.name);
+      const createdRaw = ws.metadata?.createdAt ? Date.parse(ws.metadata.createdAt) : NaN;
+      const forPrune: WorkspaceForPrune = {
+        name: ws.name,
+        path: ws.path,
+        repoDirNames: (ws.metadata?.repositories ?? []).map((r) => r.directoryName),
+        lastActiveAt: session ? session.lastActiveAt.getTime() : 0,
+        createdAt: Number.isFinite(createdRaw) ? createdRaw : 0,
+      };
+      return toCandidate(forPrune, now);
+    });
+
+    const stale = candidates.filter((c) => isStale(c, days));
+
+    if (stale.length === 0) {
+      if (json) {
+        outputJson({ ok: true, days, prunable: [], protected: [], scanned: workspaces.length });
+      } else {
+        logInfo(`No workspaces inactive for ${days}+ days (scanned ${workspaces.length}).`);
+      }
+      return;
+    }
+
+    // Compute the plan. The git safety check only runs for stale workspaces.
+    const plan = await planPrune(
+      stale,
+      (c) => getAllReposStatus(c.path, c.repoDirNames, 3),
+      !!opts.includeDirty,
+    );
+
+    if (json) {
+      outputJson({
+        ok: true,
+        days,
+        scanned: workspaces.length,
+        prunable: plan.prunable.map((c) => ({ name: c.name, path: c.path, ageDays: c.ageDays, repos: c.repoDirNames.length })),
+        protected: plan.protected.map((p) => ({ name: p.candidate.name, ageDays: p.candidate.ageDays, reason: p.reason })),
+      });
+      return;
+    }
+
+    // Human report.
+    console.log('\n' + '='.repeat(60));
+    console.log(colorize(`Prune — workspaces inactive for ${days}+ days`, 'bright'));
+    console.log('='.repeat(60) + '\n');
+
+    if (plan.protected.length > 0) {
+      logWarning(`Protected (${plan.protected.length}) — skipped due to unsaved work:`);
+      for (const p of plan.protected) {
+        console.log(`  ${colorize('•', 'yellow')} ${colorize(p.candidate.name, 'cyan')} — ${p.reason} ${colorize(`(${ageLabel(p.candidate)})`, 'gray')}`);
+      }
+      console.log('');
+    }
+
+    if (plan.prunable.length === 0) {
+      logInfo('Nothing safe to prune.');
+      if (plan.protected.length > 0) logInfo('Re-run with --include-dirty to include the protected ones (careful).');
+      return;
+    }
+
+    console.log(`${colorize('Prunable', 'bright')} (${plan.prunable.length}):`);
+    for (const c of plan.prunable) {
+      const repoLabel = c.repoDirNames.length === 1 ? '1 repo' : `${c.repoDirNames.length} repos`;
+      console.log(`  ${colorize('✗', 'red')} ${colorize(c.name, 'cyan')} ${colorize(`(${ageLabel(c)}, ${repoLabel})`, 'gray')}`);
+    }
+    console.log('');
+
+    if (opts.dryRun) {
+      logInfo(`Dry run — nothing deleted. ${plan.prunable.length} workspace(s) would be pruned.`);
+      return;
+    }
+
+    logWarning('This permanently deletes the selected workspaces and every cloned repo inside them!');
+
+    if (!opts.yes) {
+      const confirmed = await confirm({
+        message: plan.prunable.length === 1
+          ? `Prune workspace ${plan.prunable[0].name}?`
+          : `Prune these ${plan.prunable.length} workspaces?`,
+        default: false,
+      });
+      if (!confirmed) {
+        logInfo('Prune cancelled');
+        return;
+      }
+    }
+
+    let deleted = 0;
+    for (const c of plan.prunable) {
+      let target: string;
+      try {
+        // Re-validate through the same choke point delete uses: enforces the
+        // name allowlist and pins the path inside WORKSPACES_DIR.
+        target = safeWorkspacePath(c.name);
+      } catch (error) {
+        logError(error instanceof Error ? error.message : `Invalid workspace name "${c.name}"`);
+        continue;
+      }
+      try {
+        await fs.rm(target, { recursive: true, force: true });
+        logSuccess(`Pruned "${colorize(c.name, 'cyan')}"`);
+        deleted++;
+      } catch (error) {
+        logError(`Failed to prune "${c.name}"`);
+        if (error instanceof Error) logError(error.message);
+      }
+    }
+    logStep(`Pruned ${deleted} of ${plan.prunable.length} workspace(s).`);
+  } catch (error) {
+    if (json) outputJsonError(error instanceof Error ? error.message : 'prune failed');
+    else logError(error instanceof Error ? error.message : 'prune failed');
+    process.exit(1);
+  }
+}
+
+function ageLabel(c: PruneCandidate): string {
+  const base = c.ageDays === 1 ? '1 day' : `${c.ageDays} days`;
+  return c.fromSession ? `${base} since last session` : `${base} since created, no sessions`;
+}

package/src/commands/remove-repo.ts

@@ -6,13 +6,10 @@ import { loadMetadata, saveMetadata } from '../utils/workspace-meta';
 import { generateClaudeContext } from '../utils/claude-integration';
 import { logInfo, logSuccess, logError, logStep } from '../utils/logger';
 import { colorize } from '../utils/colors';
-import inquirer from 'inquirer';
-import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import { confirm, search } from '../utils/prompt';
 import * as fuzzy from 'fuzzy';
 import { getGlobalOpts, resolveWorkspace, parseList } from '../utils/command-helpers';
 
-inquirer.registerPrompt('autocomplete', autocompletePrompt);
-
 export function registerRemoveRepoCommand(parent: Command) {
   parent
     .command('remove-repo')
@@ -75,10 +72,9 @@ async function handleRemoveRepo(opts: {
         await fs.rm(workspacePath, { recursive: true, force: true });
         logSuccess(`Workspace "${workspaceName}" deleted.`);
       } else {
-        const { deleteWorkspace } = await inquirer.prompt([{
-          type: 'confirm', name: 'deleteWorkspace',
+        const deleteWorkspace = await confirm({
           message: `Delete the entire workspace folder "${workspaceName}"?`, default: false,
-        }]);
+        });
         if (deleteWorkspace) {
           await fs.rm(workspacePath, { recursive: true, force: true });
           logSuccess(`Workspace "${workspaceName}" deleted.`);
@@ -115,11 +111,11 @@ async function handleRemoveRepo(opts: {
         }
 
         try {
-          const { repoDir } = await inquirer.prompt([{
-            type: 'autocomplete', name: 'repoDir',
+          const repoDir = await search<string>({
             message: `Search and select repository (${colorize(String(selectedDirs.length), 'cyan')} selected):`,
-            source: async (_answersSoFar: any, input: string | undefined) => {
-              const searchInput = input || '';
+            pageSize: 16,
+            source: async (term: string | undefined) => {
+              const searchInput = term || '';
               const doneOption = { name: colorize('done - Finish selection', 'green'), value: 'done' };
               if (!searchInput || searchInput.toLowerCase().startsWith('done')) {
                 return [doneOption, ...available.map(e => ({ name: e.displayName, value: e.dirName }))];
@@ -127,8 +123,7 @@ async function handleRemoveRepo(opts: {
               const results = fuzzy.filter(searchInput, available, { extract: (e) => e.displayName });
               return [doneOption, ...results.map(result => ({ name: result.original.displayName, value: result.original.dirName }))];
             },
-            pageSize: 16,
-          } as any]);
+          });
 
           if (repoDir === 'done') {
             if (selectedDirs.length === 0) { console.log(colorize('\nYou must select at least one repository\n', 'yellow')); continue; }
@@ -147,11 +142,10 @@ async function handleRemoveRepo(opts: {
     console.log('');
 
     if (!opts.yes) {
-      const { confirm } = await inquirer.prompt([{
-        type: 'confirm', name: 'confirm',
+      const confirmed = await confirm({
         message: `Remove ${selectedDirs.length} instance(s)? This will delete the directories.`, default: false,
-      }]);
-      if (!confirm) { logInfo('Removal cancelled'); process.exit(0); }
+      });
+      if (!confirmed) { logInfo('Removal cancelled'); process.exit(0); }
     }
 
     logStep(4, 4, 'Removing instances...');

package/src/commands/save-context.ts

@@ -6,7 +6,7 @@ import { logInfo, logSuccess, logError } from '../utils/logger';
 import { colorize } from '../utils/colors';
 import { loadMetadata, saveMetadata, listWorkspaces } from '../utils/workspace-meta';
 import { formatContextFile, appendToContextFile } from '../utils/context-file';
-import inquirer from 'inquirer';
+import { select } from '../utils/prompt';
 
 const CONTEXT_FILENAME = 'CONTEXT.md';
 
@@ -66,12 +66,10 @@ async function resolveWorkspacePath(workspaceName?: string): Promise<{ name: str
       logError('No workspaces found');
       return null;
     }
-    const { selected } = await inquirer.prompt([{
-      type: 'list',
-      name: 'selected',
+    const selected = await select({
       message: 'Select workspace:',
       choices: workspaces.map(w => ({ name: w.name, value: w.name })),
-    }]);
+    });
     return { name: selected, path: path.join(WORKSPACES_DIR, selected) };
   }
 

package/src/commands/sessions.ts

@@ -7,12 +7,9 @@ import { listWorkspaces } from '../utils/workspace-meta';
 import { logError, logInfo } from '../utils/logger';
 import { outputJson, outputJsonError } from '../utils/output';
 import { colorize } from '../utils/colors';
-import inquirer from 'inquirer';
-import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import { search } from '../utils/prompt';
 import * as fuzzy from 'fuzzy';
 
-inquirer.registerPrompt('autocomplete', autocompletePrompt);
-
 const TEMP_FILE = path.join(os.homedir(), '.workspace-last-go');
 const RESUME_FLAG_FILE = path.join(os.homedir(), '.workspace-resume-session');
 
@@ -85,11 +82,11 @@ async function handleSessions(opts: { json?: boolean } = {}) {
     }
     console.log('');
 
-    const { selected } = await inquirer.prompt([{
-      type: 'autocomplete', name: 'selected',
+    const selected = await search<WorkspaceSession>({
       message: 'Select workspace to resume:',
-      source: async (_answersSoFar: any, input: string | undefined) => {
-        const searchInput = input || '';
+      pageSize: 15,
+      source: async (term: string | undefined) => {
+        const searchInput = term || '';
         const source = items.map(item => ({
           name: `${item.session.workspaceName}  ${colorize(item.session.lastActiveLabel, 'dim')}  ${colorize(item.repoLabel, 'dim')}`,
           value: item.session,
@@ -101,8 +98,7 @@ async function handleSessions(opts: { json?: boolean } = {}) {
           value: result.original.session,
         }));
       },
-      pageSize: 15,
-    } as any]);
+    });
 
     const session = selected as WorkspaceSession;
     await fs.writeFile(TEMP_FILE, session.workspacePath, 'utf-8');

package/src/commands/suite/create.ts

@@ -7,37 +7,27 @@ import { logInfo, logSuccess, logError, logStep } from '../../utils/logger';
 import { colorize } from '../../utils/colors';
 import { saveSuite, getSuite, validateSuiteName } from '../../utils/suite';
 import { SuiteEntry, WorkspaceSuite, PostCloneHook } from '../../types';
-import inquirer from 'inquirer';
+import { confirm, input, select } from '../../utils/prompt';
 
 async function promptSuiteDetails(defaultName?: string): Promise<{ name: string; description: string }> {
-  const { name, description } = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'name',
-      message: 'Suite name:',
-      default: defaultName,
-      validate: (input: string) => validateSuiteName(input.trim()),
-      filter: (input: string) => input.trim(),
-    },
-    {
-      type: 'input',
-      name: 'description',
-      message: 'Suite description (optional):',
-    },
-  ]);
+  const name = (await input({
+    message: 'Suite name:',
+    default: defaultName,
+    validate: (input: string) => validateSuiteName(input.trim()),
+  })).trim();
+
+  const description = await input({
+    message: 'Suite description (optional):',
+  });
 
   return { name, description: description || '' };
 }
 
 async function promptPostCloneHooks(): Promise<PostCloneHook[] | undefined> {
-  const { addHooks } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'addHooks',
-      message: 'Add post-clone hooks?',
-      default: false,
-    },
-  ]);
+  const addHooks = await confirm({
+    message: 'Add post-clone hooks?',
+    default: false,
+  });
 
   if (!addHooks) return undefined;
 
@@ -45,13 +35,9 @@ async function promptPostCloneHooks(): Promise<PostCloneHook[] | undefined> {
   console.log('Enter commands one at a time. Type "done" when finished.\n');
 
   while (true) {
-    const { command } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'command',
-        message: `Command ${commands.length + 1} (or "done"):`,
-      },
-    ]);
+    const command = await input({
+      message: `Command ${commands.length + 1} (or "done"):`,
+    });
 
     if (command.trim().toLowerCase() === 'done') break;
     if (command.trim()) {
@@ -71,14 +57,10 @@ async function checkOverwrite(name: string): Promise<boolean> {
   const existing = await getSuite(name);
   if (!existing) return true;
 
-  const { overwrite } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'overwrite',
-      message: `Suite "${name}" already exists (${existing.entries.length} repos). Overwrite?`,
-      default: false,
-    },
-  ]);
+  const overwrite = await confirm({
+    message: `Suite "${name}" already exists (${existing.entries.length} repos). Overwrite?`,
+    default: false,
+  });
 
   return overwrite;
 }
@@ -211,17 +193,13 @@ export async function main() {
   console.log('='.repeat(60) + '\n');
 
   try {
-    const { mode } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'mode',
-        message: 'How would you like to create the suite?',
-        choices: [
-          { name: 'Pick repositories interactively', value: 'interactive' },
-          { name: 'Save from an existing workspace', value: 'workspace' },
-        ],
-      },
-    ]);
+    const mode = await select({
+      message: 'How would you like to create the suite?',
+      choices: [
+        { name: 'Pick repositories interactively', value: 'interactive' },
+        { name: 'Save from an existing workspace', value: 'workspace' },
+      ],
+    });
 
     if (mode === 'interactive') {
       await createInteractive();

package/src/commands/suite/delete.ts

@@ -3,7 +3,7 @@
 import { listSuites, deleteSuite } from '../../utils/suite';
 import { logInfo, logSuccess, logError } from '../../utils/logger';
 import { colorize } from '../../utils/colors';
-import inquirer from 'inquirer';
+import { confirm, select } from '../../utils/prompt';
 
 export async function main() {
   console.log('\n' + '='.repeat(60));
@@ -18,28 +18,19 @@ export async function main() {
       process.exit(0);
     }
 
-    const { suiteName } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'suiteName',
-        message: 'Select a suite to delete:',
-        choices: suites.map(s => ({
-          name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
-          value: s.name,
-          short: s.name,
-        })),
-        pageSize: 15,
-      },
-    ]);
-
-    const { confirmed } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'confirmed',
-        message: `Are you sure you want to delete suite "${suiteName}"?`,
-        default: false,
-      },
-    ]);
+    const suiteName = await select({
+      message: 'Select a suite to delete:',
+      choices: suites.map(s => ({
+        name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
+        value: s.name,
+      })),
+      pageSize: 15,
+    });
+
+    const confirmed = await confirm({
+      message: `Are you sure you want to delete suite "${suiteName}"?`,
+      default: false,
+    });
 
     if (!confirmed) {
       logInfo('Deletion cancelled');

package/src/commands/suite/export.ts

@@ -5,7 +5,7 @@ import * as path from 'path';
 import { listSuites, exportSuite, exportAllSuites } from '../../utils/suite';
 import { logInfo, logSuccess, logError } from '../../utils/logger';
 import { colorize } from '../../utils/colors';
-import inquirer from 'inquirer';
+import { input, select } from '../../utils/prompt';
 
 export async function main(opts?: { file?: string }) {
   console.log('\n' + '='.repeat(60));
@@ -20,35 +20,26 @@ export async function main(opts?: { file?: string }) {
       process.exit(0);
     }
 
-    const { mode } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'mode',
-        message: 'What would you like to export?',
-        choices: [
-          { name: 'A single suite', value: 'single' },
-          { name: 'All suites', value: 'all' },
-        ],
-      },
-    ]);
+    const mode = await select({
+      message: 'What would you like to export?',
+      choices: [
+        { name: 'A single suite', value: 'single' },
+        { name: 'All suites', value: 'all' },
+      ],
+    });
 
     let data;
     let defaultFilename: string;
 
     if (mode === 'single') {
-      const { suiteName } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'suiteName',
-          message: 'Select a suite to export:',
-          choices: suites.map(s => ({
-            name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
-            value: s.name,
-            short: s.name,
-          })),
-          pageSize: 15,
-        },
-      ]);
+      const suiteName = await select({
+        message: 'Select a suite to export:',
+        choices: suites.map(s => ({
+          name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
+          value: s.name,
+        })),
+        pageSize: 15,
+      });
 
       data = await exportSuite(suiteName);
       if (!data) {
@@ -68,14 +59,10 @@ export async function main(opts?: { file?: string }) {
     if (outputArg && !outputArg.startsWith('-')) {
       outputPath = path.resolve(outputArg);
     } else {
-      const { filePath } = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'filePath',
-          message: 'Output file path:',
-          default: `./${defaultFilename}`,
-        },
-      ]);
+      const filePath = await input({
+        message: 'Output file path:',
+        default: `./${defaultFilename}`,
+      });
       outputPath = path.resolve(filePath);
     }
 

package/src/commands/suite/import.ts

@@ -6,7 +6,7 @@ import { importSuites } from '../../utils/suite';
 import { logInfo, logSuccess, logError, logWarning } from '../../utils/logger';
 import { colorize } from '../../utils/colors';
 import { SuitesStore } from '../../types';
-import inquirer from 'inquirer';
+import { confirm, input } from '../../utils/prompt';
 
 export async function main(opts?: { file?: string }) {
   console.log('\n' + '='.repeat(60));
@@ -20,14 +20,10 @@ export async function main(opts?: { file?: string }) {
     if (fileArg && !fileArg.startsWith('-')) {
       filePath = path.resolve(fileArg);
     } else {
-      const { inputPath } = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'inputPath',
-          message: 'Path to suite JSON file:',
-          validate: (input: string) => input.trim().length > 0 || 'File path is required',
-        },
-      ]);
+      const inputPath = await input({
+        message: 'Path to suite JSON file:',
+        validate: (input: string) => input.trim().length > 0 || 'File path is required',
+      });
       filePath = path.resolve(inputPath);
     }
 
@@ -61,14 +57,10 @@ export async function main(opts?: { file?: string }) {
     }
     console.log('');
 
-    const { overwrite } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'overwrite',
-        message: 'Overwrite existing suites with the same name?',
-        default: false,
-      },
-    ]);
+    const overwrite = await confirm({
+      message: 'Overwrite existing suites with the same name?',
+      default: false,
+    });
 
     const result = await importSuites(data, overwrite);
 

package/src/commands/suite/use.ts

@@ -13,7 +13,7 @@ import { colorize } from '../../utils/colors';
 import { listSuites } from '../../utils/suite';
 import { runPostCloneHooks } from '../../utils/hooks';
 import { GitHubRepo } from '../../types';
-import inquirer from 'inquirer';
+import { select } from '../../utils/prompt';
 import { validateWorkspaceName, checkWorkspaceExists, sanitizeWorkspaceName, resolveWorkspaceNameConflict } from '../../utils/validation';
 
 export interface SuiteUseOpts {
@@ -64,19 +64,14 @@ export async function main(opts?: SuiteUseOpts) {
       }
       selectedSuite = found;
     } else {
-      const { suite } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'suite',
-          message: 'Select a suite:',
-          choices: suites.map(s => ({
-            name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
-            value: s,
-            short: s.name,
-          })),
-          pageSize: 15,
-        },
-      ]);
+      const suite = await select({
+        message: 'Select a suite:',
+        choices: suites.map(s => ({
+          name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
+          value: s,
+        })),
+        pageSize: 15,
+      });
       selectedSuite = suite;
     }
 

package/src/program.ts

@@ -39,6 +39,7 @@ import { registerCreateCommand } from './commands/create';
 import { registerListCommand } from './commands/list';
 import { registerUpdateCommand } from './commands/update';
 import { registerDeleteCommand } from './commands/delete';
+import { registerPruneCommand } from './commands/prune';
 import { registerSyncCommand } from './commands/sync';
 import { registerStatusCommand } from './commands/status';
 import { registerDiffCommand } from './commands/diff';
@@ -66,6 +67,7 @@ registerCreateCommand(program);
 registerListCommand(program);
 registerUpdateCommand(program);
 registerDeleteCommand(program);
+registerPruneCommand(program);
 registerSyncCommand(program);
 registerStatusCommand(program);
 registerDiffCommand(program);