@aladac/hu 0.1.0-a1

package/src/commands/plans.ts

@@ -0,0 +1,259 @@
+/**
+ * Plan management commands
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as readline from 'node:readline';
+import { defineCommand } from 'citty';
+import { c } from '../lib/colors.ts';
+import { PLANS_DIR, exists, getStats, readFile } from '../lib/fs.ts';
+import type { PlanInfo } from '../types/index.ts';
+
+// ─────────────────────────────────────────────────────────────
+// List Plans
+// ─────────────────────────────────────────────────────────────
+
+function extractTitle(content: string): string | null {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+
+function extractBullets(content: string, limit = 3): string[] {
+  const bullets: string[] = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const match = line.match(/^\s*[-*]\s+(.+)$/) || line.match(/^\s*\d+\.\s+(.+)$/);
+    if (match) {
+      const text = match[1].trim();
+      const clean = text.replace(/^\[[ x]\]\s*/i, '');
+      if (clean.length > 0 && clean.length < 100) {
+        bullets.push(clean);
+        if (bullets.length >= limit) break;
+      }
+    }
+  }
+
+  return bullets;
+}
+
+function extractPhases(content: string): string[] {
+  const phases: string[] = [];
+  const matches = content.matchAll(/^##\s+(?:Phase\s+\d+[:\s]*)?(.+)$/gm);
+  for (const match of matches) {
+    phases.push(match[1].trim());
+  }
+  return phases;
+}
+
+function getPlanInfo(filePath: string, full: boolean): PlanInfo | null {
+  const stats = getStats(filePath);
+  const content = readFile(filePath);
+  if (!stats || !content) return null;
+
+  const filename = path.basename(filePath, '.md');
+
+  return {
+    filename,
+    path: filePath,
+    title: extractTitle(content) || filename,
+    bullets: extractBullets(content, full ? 6 : 3),
+    phases: extractPhases(content),
+    size: stats.size,
+    modified: stats.mtime.toISOString().split('T')[0],
+    resumeCmd: `claude -r "${filename}"`,
+  };
+}
+
+function listPlans(format: string, full: boolean): void {
+  if (!exists(PLANS_DIR)) {
+    if (format === 'json') {
+      console.log(JSON.stringify({ plans: [], count: 0 }));
+    } else {
+      console.log('No plans directory found.');
+    }
+    return;
+  }
+
+  const files = fs
+    .readdirSync(PLANS_DIR)
+    .filter((f) => f.endsWith('.md'))
+    .map((f) => path.join(PLANS_DIR, f));
+
+  if (files.length === 0) {
+    if (format === 'json') {
+      console.log(JSON.stringify({ plans: [], count: 0 }));
+    } else {
+      console.log('No plans found in ~/.claude/plans/');
+    }
+    return;
+  }
+
+  const plans = files
+    .map((f) => getPlanInfo(f, full))
+    .filter((plan): plan is PlanInfo => plan !== null);
+  plans.sort((a, b) => b.modified.localeCompare(a.modified));
+
+  if (format === 'json') {
+    console.log(JSON.stringify({ plans, count: plans.length }, null, 2));
+  } else if (format === 'simple') {
+    for (const plan of plans) {
+      console.log(plan.filename);
+    }
+  } else {
+    console.log(`Found ${plans.length} plan(s) in ~/.claude/plans/\n`);
+
+    for (const plan of plans) {
+      console.log(`## ${plan.filename} - ${plan.title}`);
+
+      if (plan.phases.length > 0) {
+        console.log(
+          `   Phases: ${plan.phases.slice(0, 4).join(', ')}${plan.phases.length > 4 ? '...' : ''}`,
+        );
+      }
+
+      if (plan.bullets.length > 0) {
+        for (const bullet of plan.bullets) {
+          console.log(`   - ${bullet}`);
+        }
+      }
+
+      console.log(`   Modified: ${plan.modified}`);
+      console.log(`   Resume: ${plan.resumeCmd}`);
+      console.log('---');
+    }
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Clear Plans
+// ─────────────────────────────────────────────────────────────
+
+async function confirm(message: string): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+async function clearPlans(options: { dryRun?: boolean; force?: boolean }): Promise<void> {
+  if (!exists(PLANS_DIR)) {
+    console.log('No plans directory found.');
+    return;
+  }
+
+  const files = fs.readdirSync(PLANS_DIR).filter((f) => f.endsWith('.md'));
+
+  if (files.length === 0) {
+    console.log('No plans to clear.');
+    return;
+  }
+
+  // Show what will be deleted
+  console.log(`Found ${files.length} plan(s) to delete:`);
+  for (const file of files) {
+    const filePath = path.join(PLANS_DIR, file);
+    const content = readFile(filePath);
+    const title = content?.match(/^#\s+(.+)$/m)?.[1] || file;
+    console.log(`  - ${file} — ${title}`);
+  }
+  console.log();
+
+  if (options.dryRun) {
+    console.log(`${c.yellow}Dry run:${c.reset} No files deleted.`);
+    return;
+  }
+
+  // Confirm unless --force
+  if (!options.force) {
+    const confirmed = await confirm(
+      `${c.yellow}Delete all ${files.length} plans? (This cannot be undone)${c.reset}`,
+    );
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return;
+    }
+  }
+
+  for (const file of files) {
+    fs.unlinkSync(path.join(PLANS_DIR, file));
+  }
+  console.log(`${c.green}✓${c.reset} Deleted ${files.length} plan(s)`);
+}
+
+// ─────────────────────────────────────────────────────────────
+// Subcommands
+// ─────────────────────────────────────────────────────────────
+
+const listCommand = defineCommand({
+  meta: {
+    name: 'list',
+    description: 'List saved plans from ~/.claude/plans/',
+  },
+  args: {
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+    },
+    simple: {
+      type: 'boolean',
+      alias: 's',
+      description: 'Output as simple list (filenames only)',
+    },
+    full: {
+      type: 'boolean',
+      alias: 'f',
+      description: 'Show more content preview',
+    },
+  },
+  run: ({ args }) => {
+    const format = args.json ? 'json' : args.simple ? 'simple' : 'default';
+    listPlans(format, args.full || false);
+  },
+});
+
+const clearCommand = defineCommand({
+  meta: {
+    name: 'clear',
+    description: 'Delete all plans from ~/.claude/plans/',
+  },
+  args: {
+    dryRun: {
+      type: 'boolean',
+      alias: 'd',
+      description: 'Show what would be deleted without deleting',
+    },
+    force: {
+      type: 'boolean',
+      alias: 'f',
+      description: 'Skip confirmation prompt',
+    },
+  },
+  run: async ({ args }) => {
+    await clearPlans({ dryRun: args.dryRun, force: args.force });
+  },
+});
+
+// ─────────────────────────────────────────────────────────────
+// Main Command
+// ─────────────────────────────────────────────────────────────
+
+export const plansCommand = defineCommand({
+  meta: {
+    name: 'plans',
+    description: 'Plan management tools',
+  },
+  subCommands: {
+    list: listCommand,
+    clear: clearCommand,
+  },
+});

package/src/commands/utils.ts

@@ -0,0 +1,299 @@
+/**
+ * Utility commands
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { defineCommand } from 'citty';
+import { c } from '../lib/colors.ts';
+import { exists, findRepoRoot, readFile, writeFile } from '../lib/fs.ts';
+import { fetchAndConvert } from '../lib/html.ts';
+import type { CheckboxResult } from '../types/index.ts';
+
+// ─────────────────────────────────────────────────────────────
+// Fetch HTML
+// ─────────────────────────────────────────────────────────────
+
+async function fetchHtml(
+  url: string,
+  options: {
+    output?: string;
+    selector?: string;
+    title?: boolean;
+    clean?: boolean;
+    raw?: boolean;
+  },
+): Promise<void> {
+  const markdown = await fetchAndConvert(url, {
+    selector: options.selector,
+    includeTitle: options.title,
+    clean: options.clean,
+    raw: options.raw,
+  });
+
+  if (options.output) {
+    writeFile(options.output, markdown);
+    console.error(`Written to ${options.output} (${markdown.length} bytes)`);
+  } else {
+    console.log(markdown);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Sync Checkboxes
+// ─────────────────────────────────────────────────────────────
+
+function processFile(filePath: string): CheckboxResult {
+  if (!exists(filePath)) {
+    return { file: filePath, exists: false, changed: false };
+  }
+
+  const content = readFile(filePath);
+  if (!content) {
+    return { file: filePath, exists: false, changed: false };
+  }
+
+  const lines = content.split('\n');
+
+  const beforePending = (content.match(/- \[ \]/g) || []).length;
+  const beforeCompleted = (content.match(/- \[x\]/gi) || []).length;
+
+  if (beforePending === 0 && beforeCompleted === 0) {
+    return {
+      file: filePath,
+      exists: true,
+      changed: false,
+      reason: 'no checkboxes found',
+    };
+  }
+
+  if (beforePending === 0 && beforeCompleted > 0) {
+    return {
+      file: filePath,
+      exists: true,
+      changed: true,
+      delete: true,
+      before: { pending: beforePending, completed: beforeCompleted },
+      after: { pending: 0, completed: 0 },
+    };
+  }
+
+  const result: string[] = [];
+  let currentSection: string[] = [];
+  let currentSectionHeader: string | null = null;
+  let sectionHasPending = false;
+
+  function flushSection(): void {
+    if (currentSectionHeader === null) {
+      result.push(...currentSection);
+    } else if (sectionHasPending) {
+      result.push(currentSectionHeader);
+      for (const line of currentSection) {
+        if (!line.match(/- \[x\]/i)) {
+          result.push(line);
+        }
+      }
+    }
+    currentSection = [];
+    currentSectionHeader = null;
+    sectionHasPending = false;
+  }
+
+  for (const line of lines) {
+    if (line.match(/^#{1,6}\s/)) {
+      flushSection();
+      currentSectionHeader = line;
+      continue;
+    }
+
+    if (line.match(/- \[ \]/)) {
+      sectionHasPending = true;
+    }
+
+    currentSection.push(line);
+  }
+
+  flushSection();
+
+  let newContent = result.join('\n');
+  newContent = `${newContent.replace(/\n{3,}/g, '\n\n').trim()}\n`;
+
+  const afterPending = (newContent.match(/- \[ \]/g) || []).length;
+  const afterCompleted = (newContent.match(/- \[x\]/gi) || []).length;
+
+  const changed = newContent !== content;
+
+  return {
+    file: filePath,
+    exists: true,
+    changed,
+    delete: false,
+    before: { pending: beforePending, completed: beforeCompleted },
+    after: { pending: afterPending, completed: afterCompleted },
+    removed: beforeCompleted - afterCompleted,
+    newContent: changed ? newContent : null,
+  };
+}
+
+function syncCheckboxes(
+  files: string[],
+  options: { dryRun?: boolean; verbose?: boolean; json?: boolean },
+): void {
+  const repoRoot = findRepoRoot();
+  let filesToProcess = files;
+
+  if (filesToProcess.length === 0) {
+    filesToProcess = ['TODO.md', 'PLAN.md'].map((f) => path.join(repoRoot, f));
+  } else {
+    filesToProcess = filesToProcess.map((f) =>
+      path.isAbsolute(f) ? f : path.join(process.cwd(), f),
+    );
+  }
+
+  const results: CheckboxResult[] = [];
+  for (const file of filesToProcess) {
+    const result = processFile(file);
+    results.push(result);
+
+    if (!options.dryRun && result.changed) {
+      if (result.delete) {
+        fs.unlinkSync(file);
+      } else if (result.newContent) {
+        writeFile(file, result.newContent);
+      }
+    }
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    for (const r of results) {
+      const name = path.basename(r.file);
+
+      if (!r.exists) {
+        console.log(`${name}: not found`);
+        continue;
+      }
+
+      if (!r.changed) {
+        console.log(`${name}: unchanged${r.reason ? ` (${r.reason})` : ''}`);
+        continue;
+      }
+
+      if (r.delete) {
+        const action = options.dryRun ? 'would delete' : 'deleted';
+        console.log(`${name}: ${action} (all ${r.before?.completed} items complete)`);
+      } else {
+        const action = options.dryRun ? 'would remove' : 'removed';
+        console.log(
+          `${name}: ${action} ${r.removed} completed items (${r.after?.pending} pending remain)`,
+        );
+      }
+
+      if (options.verbose && r.before) {
+        console.log(`  Before: ${r.before.pending} pending, ${r.before.completed} completed`);
+        console.log(`  After:  ${r.after?.pending} pending, ${r.after?.completed} completed`);
+      }
+    }
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Subcommands
+// ─────────────────────────────────────────────────────────────
+
+const fetchHtmlCommand = defineCommand({
+  meta: {
+    name: 'fetch-html',
+    description: 'Fetch a URL and convert HTML to markdown',
+  },
+  args: {
+    url: {
+      type: 'positional',
+      description: 'URL to fetch',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Write to file instead of stdout',
+    },
+    selector: {
+      type: 'string',
+      alias: 's',
+      description: 'CSS selector for main content',
+    },
+    title: {
+      type: 'boolean',
+      alias: 't',
+      description: 'Include page title as H1',
+    },
+    clean: {
+      type: 'boolean',
+      alias: 'c',
+      description: 'Extra cleaning (remove nav, footer, ads)',
+    },
+    raw: {
+      type: 'boolean',
+      alias: 'r',
+      description: 'Output raw markdown without post-processing',
+    },
+  },
+  run: async ({ args }) => {
+    await fetchHtml(args.url as string, {
+      output: args.output as string | undefined,
+      selector: args.selector as string | undefined,
+      title: args.title,
+      clean: args.clean,
+      raw: args.raw,
+    });
+  },
+});
+
+const syncCheckboxesCommand = defineCommand({
+  meta: {
+    name: 'sync-checkboxes',
+    description: 'Remove completed items from TODO.md/PLAN.md',
+  },
+  args: {
+    dryRun: {
+      type: 'boolean',
+      alias: 'd',
+      description: 'Show what would change without modifying files',
+    },
+    verbose: {
+      type: 'boolean',
+      alias: 'v',
+      description: 'Show detailed output',
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output results as JSON',
+    },
+  },
+  run: ({ args, rawArgs }) => {
+    // rawArgs contains everything after --, or non-flag arguments
+    const files = rawArgs.filter((arg) => !arg.startsWith('-'));
+    syncCheckboxes(files, {
+      dryRun: args.dryRun,
+      verbose: args.verbose,
+      json: args.json,
+    });
+  },
+});
+
+// ─────────────────────────────────────────────────────────────
+// Main Command
+// ─────────────────────────────────────────────────────────────
+
+export const utilsCommand = defineCommand({
+  meta: {
+    name: 'utils',
+    description: 'Utility commands',
+  },
+  subCommands: {
+    'fetch-html': fetchHtmlCommand,
+    'sync-checkboxes': syncCheckboxesCommand,
+  },
+});

package/src/index.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * hu - CLI tools for Claude Code workflows
+ */
+
+import { defineCommand, runMain } from 'citty';
+import { diskCommand } from './commands/disk.ts';
+import { docsCommand } from './commands/docs.ts';
+import { plansCommand } from './commands/plans.ts';
+import { utilsCommand } from './commands/utils.ts';
+
+const main = defineCommand({
+  meta: {
+    name: 'hu',
+    version: '0.1.0-a1',
+    description: 'CLI tools for Claude Code workflows',
+  },
+  subCommands: {
+    disk: diskCommand,
+    docs: docsCommand,
+    plans: plansCommand,
+    utils: utilsCommand,
+  },
+});
+
+runMain(main);

package/src/lib/colors.ts

@@ -0,0 +1,87 @@
+/**
+ * ANSI color codes for terminal output
+ */
+export const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  bgBlue: '\x1b[44m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgRed: '\x1b[41m',
+} as const;
+
+/**
+ * Parse size string (e.g., "10G", "500M") to bytes
+ */
+export function parseSize(sizeStr: string): number {
+  const match = sizeStr.match(/^([\d.]+)([KMGTP]?)$/i);
+  if (!match) return 0;
+  const num = Number.parseFloat(match[1]);
+  const unit = (match[2] || 'B').toUpperCase();
+  const multipliers: Record<string, number> = {
+    B: 1,
+    K: 1024,
+    M: 1024 ** 2,
+    G: 1024 ** 3,
+    T: 1024 ** 4,
+    P: 1024 ** 5,
+  };
+  return num * (multipliers[unit] || 1);
+}
+
+/**
+ * Format bytes to human-readable size string
+ */
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+/**
+ * Colorize size string based on magnitude
+ */
+export function colorizeSize(sizeStr: string): string {
+  const bytes = parseSize(sizeStr.replace(/\s/g, ''));
+  if (bytes >= 50 * 1024 ** 3) return `${c.red}${c.bold}${sizeStr}${c.reset}`;
+  if (bytes >= 10 * 1024 ** 3) return `${c.yellow}${sizeStr}${c.reset}`;
+  if (bytes >= 1 * 1024 ** 3) return `${c.cyan}${sizeStr}${c.reset}`;
+  return `${c.dim}${sizeStr}${c.reset}`;
+}
+
+/**
+ * Create a progress bar string
+ */
+export function progressBar(percent: number, width = 30): string {
+  const filled = Math.round((width * percent) / 100);
+  const empty = width - filled;
+  let color: string = c.green;
+  if (percent > 80) color = c.red;
+  else if (percent > 60) color = c.yellow;
+  return `${color}${'█'.repeat(filled)}${c.dim}${'░'.repeat(empty)}${c.reset}`;
+}
+
+/**
+ * Print a section header
+ */
+export function printHeader(text: string): void {
+  console.log();
+  console.log(`${c.bgBlue}${c.white}${c.bold} ${text} ${c.reset}`);
+  console.log();
+}
+
+/**
+ * Print a sub-header
+ */
+export function printSubHeader(text: string): void {
+  console.log(`${c.cyan}${c.bold}▸ ${text}${c.reset}`);
+}

package/src/lib/exec.ts

@@ -0,0 +1,25 @@
+import { execSync } from 'node:child_process';
+
+/**
+ * Execute a shell command and return the output
+ * Returns empty string on error
+ */
+export function exec(cmd: string): string {
+  try {
+    return execSync(cmd, { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 }).trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Execute a shell command and return success status
+ */
+export function execSuccess(cmd: string): boolean {
+  try {
+    execSync(cmd, { encoding: 'utf8', stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}