@aladac/hu 0.1.0-a1 → 0.1.0-a2

package/src/commands/plugin.ts

@@ -0,0 +1,216 @@
+/**
+ * hu plugin - Plugin management commands
+ */
+
+import { defineCommand } from 'citty';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { c } from '../lib/colors.ts';
+
+// Plugin manifest template
+function getManifest(name: string): object {
+  return {
+    name,
+    version: '0.1.0',
+    description: 'Claude Code data integration plugin - provides session context, similarity search, and usage tracking',
+    author: 'hu',
+    hooks: {
+      SessionStart: [
+        {
+          matcher: '.*',
+          hooks: [
+            {
+              type: 'command',
+              command: path.join('$PLUGIN_DIR', 'hooks', 'session-start.sh'),
+            },
+          ],
+        },
+      ],
+      Stop: [
+        {
+          matcher: '.*',
+          hooks: [
+            {
+              type: 'command',
+              command: path.join('$PLUGIN_DIR', 'hooks', 'stop.sh'),
+            },
+          ],
+        },
+      ],
+    },
+  };
+}
+
+// Session start hook script
+const sessionStartHook = `#!/bin/bash
+# Session Start Hook - Load context from previous sessions
+set -e
+
+INPUT_FILE=$(mktemp /tmp/hu-session-start-XXXXXX.json)
+cat > "$INPUT_FILE"
+
+PROJECT=$(jq -r '.cwd // empty' "$INPUT_FILE" 2>/dev/null || echo "")
+rm -f "$INPUT_FILE"
+
+if ! command -v hu &> /dev/null; then
+    exit 0
+fi
+
+hu data sync --quiet 2>/dev/null || true
+
+SESSIONS_FILE=$(mktemp /tmp/hu-sessions-XXXXXX.json)
+if [ -n "$PROJECT" ]; then
+    hu data session list --project "$PROJECT" --limit 5 --json > "$SESSIONS_FILE" 2>/dev/null || echo "[]" > "$SESSIONS_FILE"
+else
+    hu data session list --limit 5 --json > "$SESSIONS_FILE" 2>/dev/null || echo "[]" > "$SESSIONS_FILE"
+fi
+
+TODOS_FILE=$(mktemp /tmp/hu-todos-XXXXXX.json)
+if [ -n "$PROJECT" ]; then
+    hu data todos pending --project "$PROJECT" --json > "$TODOS_FILE" 2>/dev/null || echo "[]" > "$TODOS_FILE"
+else
+    hu data todos pending --json > "$TODOS_FILE" 2>/dev/null || echo "[]" > "$TODOS_FILE"
+fi
+
+SESSION_COUNT=$(jq 'length' "$SESSIONS_FILE" 2>/dev/null || echo "0")
+TODO_COUNT=$(jq 'length' "$TODOS_FILE" 2>/dev/null || echo "0")
+
+CONTEXT=""
+
+if [ "$SESSION_COUNT" -gt 0 ]; then
+    CONTEXT="## Previous Sessions\\n\\n"
+    CONTEXT+=$(jq -r '.[] | "- Session \\(.id[0:8]): \\(.display // "No description") (\\(.message_count) messages)"' "$SESSIONS_FILE" 2>/dev/null || echo "")
+    CONTEXT+="\\n\\n"
+fi
+
+if [ "$TODO_COUNT" -gt 0 ]; then
+    CONTEXT+="## Pending Tasks\\n\\n"
+    CONTEXT+=$(jq -r '.[] | "- [\\(.status)] \\(.content)"' "$TODOS_FILE" 2>/dev/null || echo "")
+fi
+
+rm -f "$SESSIONS_FILE" "$TODOS_FILE"
+
+if [ -n "$CONTEXT" ]; then
+    CONTEXT_ESCAPED=$(echo -e "$CONTEXT" | jq -Rs .)
+    echo "{\\"additionalContext\\": $CONTEXT_ESCAPED}"
+else
+    echo "{}"
+fi
+`;
+
+// Stop hook script
+const stopHook = `#!/bin/bash
+# Stop Hook - Sync session data on stop
+set -e
+
+INPUT_FILE=$(mktemp /tmp/hu-stop-XXXXXX.json)
+cat > "$INPUT_FILE"
+
+STOP_HOOK_ACTIVE=$(jq -r '.stop_hook_active // false' "$INPUT_FILE" 2>/dev/null || echo "false")
+if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
+    rm -f "$INPUT_FILE"
+    echo "{}"
+    exit 0
+fi
+
+rm -f "$INPUT_FILE"
+
+if ! command -v hu &> /dev/null; then
+    echo "{}"
+    exit 0
+fi
+
+hu data sync --quiet 2>/dev/null || true
+echo "{}"
+`;
+
+// Create plugin subcommand
+const createCommand = defineCommand({
+  meta: {
+    name: 'create',
+    description: 'Create a Claude Code plugin from hu hooks',
+  },
+  args: {
+    output: {
+      type: 'positional',
+      description: 'Output directory for the plugin',
+      required: true,
+    },
+    name: {
+      type: 'string',
+      alias: 'n',
+      description: 'Plugin name',
+      default: 'hu-data',
+    },
+  },
+  run: ({ args }) => {
+    const outputDir = path.resolve(args.output);
+    const hooksDir = path.join(outputDir, 'hooks');
+
+    // Create directories
+    fs.mkdirSync(hooksDir, { recursive: true });
+
+    // Write manifest
+    const manifestPath = path.join(outputDir, 'manifest.json');
+    const manifest = getManifest(args.name);
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    console.log(`${c.green}✓${c.reset} Created ${manifestPath}`);
+
+    // Write hooks
+    const sessionStartPath = path.join(hooksDir, 'session-start.sh');
+    fs.writeFileSync(sessionStartPath, sessionStartHook);
+    fs.chmodSync(sessionStartPath, 0o755);
+    console.log(`${c.green}✓${c.reset} Created ${sessionStartPath}`);
+
+    const stopPath = path.join(hooksDir, 'stop.sh');
+    fs.writeFileSync(stopPath, stopHook);
+    fs.chmodSync(stopPath, 0o755);
+    console.log(`${c.green}✓${c.reset} Created ${stopPath}`);
+
+    // Write README
+    const readmePath = path.join(outputDir, 'README.md');
+    const readme = `# ${args.name}
+
+Claude Code data integration plugin.
+
+## Features
+
+- **Session Context** - Loads recent sessions and pending todos on session start
+- **Auto Sync** - Syncs session data to SQLite on session end
+
+## Requirements
+
+- \`hu\` CLI installed and in PATH (\`npm install -g @aladac/hu\`)
+- \`jq\` for JSON processing
+
+## Installation
+
+1. Copy this directory to your Claude Code plugins folder
+2. Or symlink: \`ln -s ${outputDir} ~/.claude/plugins/${args.name}\`
+
+## Configuration
+
+The plugin uses \`~/.config/hu/settings.toml\` for configuration.
+See \`hu data config\` for current settings.
+`;
+    fs.writeFileSync(readmePath, readme);
+    console.log(`${c.green}✓${c.reset} Created ${readmePath}`);
+
+    console.log(`\n${c.bold}Plugin created at ${outputDir}${c.reset}`);
+    console.log(`\nTo install, add to ~/.claude/settings.json:`);
+    console.log(`${c.dim}  "pluginDirectory": "${outputDir}"${c.reset}`);
+    console.log(`\nOr symlink to plugins folder:`);
+    console.log(`${c.dim}  ln -s ${outputDir} ~/.claude/plugins/${args.name}${c.reset}`);
+  },
+});
+
+// Main plugin command
+export const pluginCommand = defineCommand({
+  meta: {
+    name: 'plugin',
+    description: 'Plugin management commands',
+  },
+  subCommands: {
+    create: createCommand,
+  },
+});

package/src/index.ts

@@ -4,21 +4,25 @@
  */
 
 import { defineCommand, runMain } from 'citty';
+import { dataCommand } from './commands/data.ts';
 import { diskCommand } from './commands/disk.ts';
 import { docsCommand } from './commands/docs.ts';
 import { plansCommand } from './commands/plans.ts';
+import { pluginCommand } from './commands/plugin.ts';
 import { utilsCommand } from './commands/utils.ts';
 
 const main = defineCommand({
   meta: {
     name: 'hu',
-    version: '0.1.0-a1',
+    version: '0.1.0-a2',
     description: 'CLI tools for Claude Code workflows',
   },
   subCommands: {
+    data: dataCommand,
     disk: diskCommand,
     docs: docsCommand,
     plans: plansCommand,
+    plugin: pluginCommand,
     utils: utilsCommand,
   },
 });

package/src/lib/claude-paths.ts

@@ -0,0 +1,136 @@
+/**
+ * Utilities to locate Claude Code data files
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getClaudeDir } from './config.ts';
+
+/**
+ * Get the projects directory containing session transcripts
+ * Each project is stored in a base64-encoded subdirectory
+ */
+export function getProjectsDir(): string {
+  return path.join(getClaudeDir(), 'projects');
+}
+
+/**
+ * Get the history.jsonl file path
+ */
+export function getHistoryPath(): string {
+  return path.join(getClaudeDir(), 'history.jsonl');
+}
+
+/**
+ * Get the stats-cache.json file path
+ */
+export function getStatsPath(): string {
+  return path.join(getClaudeDir(), 'stats-cache.json');
+}
+
+/**
+ * Get the todos directory
+ */
+export function getTodosDir(): string {
+  return path.join(getClaudeDir(), 'todos');
+}
+
+/**
+ * Get the debug logs directory
+ */
+export function getDebugDir(): string {
+  return path.join(getClaudeDir(), 'debug');
+}
+
+/**
+ * Get the file-history directory
+ */
+export function getFileHistoryDir(): string {
+  return path.join(getClaudeDir(), 'file-history');
+}
+
+/**
+ * Encode a project path for directory name
+ * Claude Code uses dash-based encoding:
+ * - / becomes -
+ * - /. (slash followed by dot) becomes --
+ */
+export function encodeProjectPath(projectPath: string): string {
+  // Replace /. with -- first, then / with -
+  return projectPath.replace(/\/\./g, '--').replace(/\//g, '-');
+}
+
+/**
+ * Decode a project directory name back to path
+ * Claude Code uses dash-based encoding:
+ * - -- becomes /.
+ * - - becomes /
+ */
+export function decodeProjectPath(encoded: string): string {
+  // Replace -- with /. first (dot-prefixed directories), then - with /
+  return encoded.replace(/--/g, '/.').replace(/-/g, '/');
+}
+
+/**
+ * Get session file path for a given session ID
+ * Searches through all project directories
+ */
+export function findSessionPath(sessionId: string): string | null {
+  const projectsDir = getProjectsDir();
+  
+  if (!fs.existsSync(projectsDir)) {
+    return null;
+  }
+
+  const projectDirs = fs.readdirSync(projectsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  for (const projectDir of projectDirs) {
+    const sessionPath = path.join(projectsDir, projectDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      return sessionPath;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * List all project directories with their decoded paths
+ */
+export function listProjects(): Array<{ encoded: string; path: string; dir: string }> {
+  const projectsDir = getProjectsDir();
+  
+  if (!fs.existsSync(projectsDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(projectsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => ({
+      encoded: d.name,
+      path: decodeProjectPath(d.name),
+      dir: path.join(projectsDir, d.name),
+    }));
+}
+
+/**
+ * List all session files in a project directory
+ */
+export function listSessionsInProject(projectDir: string): string[] {
+  if (!fs.existsSync(projectDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(projectDir)
+    .filter(f => f.endsWith('.jsonl'))
+    .map(f => f.replace('.jsonl', ''));
+}
+
+/**
+ * Get todos file for a session
+ */
+export function getTodosPath(sessionId: string): string {
+  return path.join(getTodosDir(), `${sessionId}.json`);
+}

package/src/lib/config.ts

@@ -0,0 +1,244 @@
+/**
+ * Configuration system for hu
+ * Location: ~/.config/hu/settings.toml
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { parse, stringify } from 'smol-toml';
+
+export interface HuConfig {
+  general: {
+    claude_dir: string;
+    database: string;
+  };
+  sync: {
+    auto_sync_interval: number;
+    sync_on_start: boolean;
+  };
+  hooks: {
+    enabled: boolean;
+    temp_dir: string;
+    temp_file_ttl: number;
+  };
+  search: {
+    default_limit: number;
+    show_snippets: boolean;
+  };
+  output: {
+    default_format: 'table' | 'json' | 'markdown';
+    colors: boolean;
+    date_format: string;
+  };
+}
+
+const DEFAULT_CONFIG: HuConfig = {
+  general: {
+    claude_dir: '~/.claude',
+    database: 'hu.db',
+  },
+  sync: {
+    auto_sync_interval: 300,
+    sync_on_start: true,
+  },
+  hooks: {
+    enabled: true,
+    temp_dir: '/tmp',
+    temp_file_ttl: 3600,
+  },
+  search: {
+    default_limit: 20,
+    show_snippets: true,
+  },
+  output: {
+    default_format: 'table',
+    colors: true,
+    date_format: '%Y-%m-%d %H:%M',
+  },
+};
+
+const DEFAULT_CONFIG_TOML = `# hu configuration
+# Location: ~/.config/hu/settings.toml
+
+[general]
+# Claude Code data directory
+claude_dir = "~/.claude"
+
+# Database location (relative to config dir or absolute)
+database = "hu.db"
+
+[sync]
+# Auto-sync interval in seconds (0 = manual only)
+auto_sync_interval = 300
+
+# Sync on startup
+sync_on_start = true
+
+[hooks]
+# Enable hook system
+enabled = true
+
+# Temp file directory for hook data exchange
+temp_dir = "/tmp"
+
+# Cleanup temp files older than (seconds)
+temp_file_ttl = 3600
+
+[search]
+# Default search result limit
+default_limit = 20
+
+# Enable FTS5 snippets in search results
+show_snippets = true
+
+[output]
+# Default output format: table, json, markdown
+default_format = "table"
+
+# Colorize output
+colors = true
+
+# Date format (strftime)
+date_format = "%Y-%m-%d %H:%M"
+`;
+
+let cachedConfig: HuConfig | null = null;
+
+/**
+ * Expand ~ to home directory
+ */
+export function expandPath(p: string): string {
+  if (p.startsWith('~/')) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  if (p === '~') {
+    return os.homedir();
+  }
+  return p;
+}
+
+/**
+ * Get the config directory path
+ */
+export function getConfigDir(): string {
+  return path.join(os.homedir(), '.config', 'hu');
+}
+
+/**
+ * Get the config file path
+ */
+export function getConfigPath(): string {
+  return path.join(getConfigDir(), 'settings.toml');
+}
+
+/**
+ * Get the database path (resolved)
+ */
+export function getDatabasePath(config?: HuConfig): string {
+  const cfg = config ?? getConfig();
+  const dbPath = cfg.general.database;
+  
+  // If absolute path, use as-is
+  if (path.isAbsolute(dbPath)) {
+    return dbPath;
+  }
+  
+  // If starts with ~, expand it
+  if (dbPath.startsWith('~')) {
+    return expandPath(dbPath);
+  }
+  
+  // Otherwise, relative to config dir
+  return path.join(getConfigDir(), dbPath);
+}
+
+/**
+ * Ensure config directory and file exist
+ */
+export function ensureConfig(): void {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+
+  // Create config directory if missing
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  // Create default config file if missing
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, DEFAULT_CONFIG_TOML, 'utf-8');
+  }
+}
+
+/**
+ * Deep merge two objects, with b taking precedence
+ */
+function deepMerge<T extends Record<string, unknown>>(a: T, b: Partial<T>): T {
+  const result = { ...a };
+  
+  for (const key of Object.keys(b) as (keyof T)[]) {
+    const bVal = b[key];
+    if (bVal !== undefined) {
+      if (
+        typeof bVal === 'object' &&
+        bVal !== null &&
+        !Array.isArray(bVal) &&
+        typeof a[key] === 'object' &&
+        a[key] !== null
+      ) {
+        result[key] = deepMerge(
+          a[key] as Record<string, unknown>,
+          bVal as Record<string, unknown>
+        ) as T[keyof T];
+      } else {
+        result[key] = bVal as T[keyof T];
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Read and parse config file
+ */
+export function getConfig(forceReload = false): HuConfig {
+  if (cachedConfig && !forceReload) {
+    return cachedConfig;
+  }
+
+  ensureConfig();
+  
+  const configPath = getConfigPath();
+  
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const parsed = parse(content) as Partial<HuConfig>;
+    
+    // Merge with defaults to ensure all fields exist
+    cachedConfig = deepMerge(DEFAULT_CONFIG, parsed);
+    return cachedConfig;
+  } catch (error) {
+    // On parse error, log warning and use defaults
+    console.error(`Warning: Failed to parse config at ${configPath}, using defaults`);
+    console.error(error instanceof Error ? error.message : String(error));
+    cachedConfig = { ...DEFAULT_CONFIG };
+    return cachedConfig;
+  }
+}
+
+/**
+ * Get Claude Code directory (resolved)
+ */
+export function getClaudeDir(config?: HuConfig): string {
+  const cfg = config ?? getConfig();
+  return expandPath(cfg.general.claude_dir);
+}
+
+/**
+ * Clear cached config (for testing)
+ */
+export function clearConfigCache(): void {
+  cachedConfig = null;
+}

package/src/lib/db.ts

@@ -0,0 +1,59 @@
+/**
+ * SQLite database module for hu
+ * Uses better-sqlite3 with WAL mode for concurrent access
+ */
+
+import Database from 'better-sqlite3';
+import type { Database as DatabaseType } from 'better-sqlite3';
+import { getDatabasePath, getConfig } from './config.ts';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+let db: DatabaseType | null = null;
+
+/**
+ * Get or create the database connection
+ */
+export function getDb(): DatabaseType {
+  if (db) {
+    return db;
+  }
+
+  const dbPath = getDatabasePath();
+  
+  // Ensure directory exists
+  const dbDir = path.dirname(dbPath);
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true });
+  }
+
+  db = new Database(dbPath);
+  
+  // Enable WAL mode for better concurrent access
+  db.pragma('journal_mode = WAL');
+  
+  // Enable foreign keys
+  db.pragma('foreign_keys = ON');
+
+  return db;
+}
+
+/**
+ * Close the database connection
+ */
+export function closeDb(): void {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+/**
+ * Get database for testing (allows passing custom path)
+ */
+export function getTestDb(dbPath: string): DatabaseType {
+  const testDb = new Database(dbPath);
+  testDb.pragma('journal_mode = WAL');
+  testDb.pragma('foreign_keys = ON');
+  return testDb;
+}