orbital-command 0.2.0 → 1.0.0

package/dist/server/server/update-planner.js

@@ -0,0 +1,279 @@
+/**
+ * Update planner — computes a structured diff between the current manifest
+ * and the new template set. Produces an UpdatePlan that can be executed
+ * or printed as a dry-run.
+ */
+import fs from 'fs';
+import path from 'path';
+import { buildTemplateInventory } from './manifest.js';
+// ─── Version Comparison ─────────────────────────────────────
+/** Parse a semver string into [major, minor, patch]. Returns null if invalid. */
+function parseSemver(version) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])];
+}
+/** Compare two semver strings. Returns -1, 0, or 1. */
+function compareSemver(a, b) {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if (!pa || !pb)
+        return 0;
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] < pb[i])
+            return -1;
+        if (pa[i] > pb[i])
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Load and chain rename maps between two versions.
+ * Returns Map<oldPath, newPath> with all renames chained.
+ */
+export function loadRenameMap(templatesDir, fromVersion, toVersion) {
+    const renamesPath = path.join(templatesDir, 'migrations', 'renames.json');
+    if (!fs.existsSync(renamesPath))
+        return new Map();
+    let rawMap;
+    try {
+        rawMap = JSON.parse(fs.readFileSync(renamesPath, 'utf-8'));
+    }
+    catch {
+        return new Map();
+    }
+    // Collect all applicable rename entries, ordered by target version
+    const applicable = [];
+    for (const [range, renames] of Object.entries(rawMap)) {
+        const parts = range.split('->');
+        if (parts.length !== 2)
+            continue;
+        const [from, to] = parts.map(s => s.trim());
+        if (!parseSemver(from) || !parseSemver(to))
+            continue;
+        // Include if: from > fromVersion (hasn't been applied) AND to <= toVersion
+        if (compareSemver(from, fromVersion) <= 0 || compareSemver(to, toVersion) > 0)
+            continue;
+        applicable.push({ to, renames });
+    }
+    // Sort by target version ascending
+    applicable.sort((a, b) => compareSemver(a.to, b.to));
+    // Chain renames: if A→B in v1 and B→C in v2, result is A→C
+    const chained = new Map();
+    for (const { renames } of applicable) {
+        for (const [oldPath, newPath] of Object.entries(renames)) {
+            // Check if oldPath is itself a rename target from a previous version
+            let originalPath = oldPath;
+            for (const [prevOld, prevNew] of chained) {
+                if (prevNew === oldPath) {
+                    originalPath = prevOld;
+                    chained.delete(prevOld);
+                    break;
+                }
+            }
+            chained.set(originalPath, newPath);
+        }
+    }
+    return chained;
+}
+/**
+ * Compute the update plan by diffing manifest against current templates.
+ * Does NOT modify any files — pure computation.
+ */
+export function computeUpdatePlan(options) {
+    const { templatesDir, claudeDir, manifest, newVersion } = options;
+    const renameMap = options.renameMap ??
+        loadRenameMap(templatesDir, manifest.packageVersion, newVersion);
+    const templateInventory = buildTemplateInventory(templatesDir);
+    const toAdd = [];
+    const toUpdate = [];
+    const toRemove = [];
+    const toRename = [];
+    const toSkip = [];
+    // Build reverse rename map: newPath → oldPath
+    const reverseRenames = new Map();
+    for (const [oldPath, newPath] of renameMap) {
+        reverseRenames.set(newPath, oldPath);
+    }
+    // 1. Check each template file against the manifest
+    for (const [templatePath, templateHash] of templateInventory) {
+        // Is this file the target of a rename?
+        const oldPath = reverseRenames.get(templatePath);
+        if (oldPath && manifest.files[oldPath]) {
+            toRename.push({ from: oldPath, to: templatePath });
+            continue;
+        }
+        const record = manifest.files[templatePath];
+        if (!record) {
+            // New file — not in manifest at all
+            toAdd.push(templatePath);
+            continue;
+        }
+        if (record.origin === 'user') {
+            // A user file occupies a path that now conflicts with a template.
+            // Skip it and warn. This is an unusual edge case.
+            toSkip.push({ file: templatePath, reason: 'modified', newTemplateHash: templateHash });
+            continue;
+        }
+        if (record.status === 'pinned') {
+            // Update the template hash in manifest but don't touch the file
+            toSkip.push({ file: templatePath, reason: 'pinned', newTemplateHash: templateHash });
+            continue;
+        }
+        if (record.status === 'modified') {
+            // User modified a template file — skip it
+            toSkip.push({ file: templatePath, reason: 'modified', newTemplateHash: templateHash });
+            continue;
+        }
+        if (record.status === 'outdated') {
+            // File content doesn't match template but user hasn't edited it — safe to update
+            toUpdate.push(templatePath);
+            continue;
+        }
+        // synced file — update only if template changed since last sync
+        if (record.templateHash !== templateHash) {
+            toUpdate.push(templatePath);
+        }
+        // else: already up to date
+    }
+    // 2. Check for files in manifest that are no longer in templates
+    for (const [filePath, record] of Object.entries(manifest.files)) {
+        if (record.origin !== 'template')
+            continue;
+        // Skip if it's in the template inventory (already handled above)
+        if (templateInventory.has(filePath))
+            continue;
+        // Skip if it's the old side of a rename (will be handled in rename step)
+        if (renameMap.has(filePath))
+            continue;
+        toRemove.push(filePath);
+    }
+    // 3. Compute settings hook changes
+    const settingsChanges = computeSettingsChanges(claudeDir, templatesDir);
+    // 4. Check for pending config migrations (placeholder — computed by config-migrator)
+    const pendingMigrations = [];
+    const isEmpty = toAdd.length === 0 &&
+        toUpdate.length === 0 &&
+        toRemove.length === 0 &&
+        toRename.length === 0 &&
+        settingsChanges.hooksToAdd.length === 0 &&
+        settingsChanges.hooksToRemove.length === 0 &&
+        pendingMigrations.length === 0;
+    return {
+        toAdd,
+        toUpdate,
+        toRemove,
+        toRename,
+        toSkip,
+        settingsChanges,
+        pendingMigrations,
+        isEmpty,
+    };
+}
+// ─── Settings Changes ───────────────────────────────────────
+/** Compute which _orbital hooks need to be added or removed from settings.local.json. */
+function computeSettingsChanges(claudeDir, templatesDir) {
+    const settingsPath = path.join(claudeDir, 'settings.local.json');
+    const templatePath = path.join(templatesDir, 'settings-hooks.json');
+    if (!fs.existsSync(templatePath)) {
+        return { hooksToAdd: [], hooksToRemove: [] };
+    }
+    // Extract all hook commands from the template
+    const newCommands = extractHookCommands(templatePath);
+    // Extract all _orbital hook commands from current settings
+    const currentCommands = new Set();
+    if (fs.existsSync(settingsPath)) {
+        try {
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (settings.hooks) {
+                for (const groups of Object.values(settings.hooks)) {
+                    for (const group of groups) {
+                        for (const hook of group.hooks || []) {
+                            if (hook._orbital)
+                                currentCommands.add(hook.command);
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* malformed settings */ }
+    }
+    const hooksToAdd = [...newCommands].filter(c => !currentCommands.has(c));
+    const hooksToRemove = [...currentCommands].filter(c => !newCommands.has(c));
+    return { hooksToAdd, hooksToRemove };
+}
+/** Extract all hook command strings from a settings-hooks.json template. */
+function extractHookCommands(templatePath) {
+    const commands = new Set();
+    try {
+        const template = JSON.parse(fs.readFileSync(templatePath, 'utf-8'));
+        if (template.hooks) {
+            for (const groups of Object.values(template.hooks)) {
+                for (const group of groups) {
+                    for (const hook of group.hooks || []) {
+                        if (hook.command)
+                            commands.add(hook.command);
+                    }
+                }
+            }
+        }
+    }
+    catch { /* malformed template */ }
+    return commands;
+}
+// ─── Plan Formatting ────────────────────────────────────────
+/** Format an update plan as a human-readable string for dry-run output. */
+export function formatPlan(plan, oldVersion, newVersion) {
+    const lines = [];
+    lines.push(`Orbital Command — update plan (dry run)\n`);
+    lines.push(`Package version: ${oldVersion} → ${newVersion}\n`);
+    if (plan.isEmpty) {
+        lines.push('  Everything up to date. No changes needed.\n');
+        return lines.join('\n');
+    }
+    for (const file of plan.toAdd) {
+        lines.push(`  ADD     ${file}`);
+    }
+    for (const file of plan.toUpdate) {
+        lines.push(`  UPDATE  ${file}`);
+    }
+    for (const { from, to } of plan.toRename) {
+        lines.push(`  RENAME  ${from} → ${to}`);
+    }
+    for (const file of plan.toRemove) {
+        lines.push(`  REMOVE  ${file}`);
+    }
+    for (const { file, reason } of plan.toSkip) {
+        lines.push(`  SKIP    ${file} (${reason})`);
+    }
+    if (plan.settingsChanges.hooksToAdd.length > 0 || plan.settingsChanges.hooksToRemove.length > 0) {
+        lines.push('');
+        lines.push(`  SETTINGS  hooks to add: ${plan.settingsChanges.hooksToAdd.length}, to remove: ${plan.settingsChanges.hooksToRemove.length}`);
+    }
+    if (plan.pendingMigrations.length > 0) {
+        lines.push(`  CONFIG    migrations: ${plan.pendingMigrations.length}`);
+    }
+    lines.push('');
+    lines.push('  REGEN   INDEX.md, workflow-manifest.sh');
+    lines.push('');
+    lines.push('No changes made. Run without --dry-run to apply.');
+    return lines.join('\n');
+}
+/**
+ * Get the list of files that need to be backed up before executing a plan.
+ * These are files that will be overwritten or deleted.
+ */
+export function getFilesToBackup(plan) {
+    const files = [];
+    for (const file of plan.toUpdate) {
+        files.push(file);
+    }
+    for (const file of plan.toRemove) {
+        files.push(file);
+    }
+    for (const { from } of plan.toRename) {
+        files.push(from);
+    }
+    return files;
+}

package/dist/server/server/update.js

@@ -0,0 +1,212 @@
+/**
+ * Template update logic — extracted from init.ts for focused maintainability.
+ */
+import fs from 'fs';
+import path from 'path';
+import { loadManifest, saveManifest, buildTemplateInventory, refreshFileStatuses, templateFileRecord, safeBackupFile, safeCopyTemplate, reverseRemapPath, } from './manifest.js';
+import { needsLegacyMigration, migrateFromLegacy } from './migrate-legacy.js';
+import { computeUpdatePlan, loadRenameMap, formatPlan, getFilesToBackup } from './update-planner.js';
+import { syncSettingsHooks, getTemplateChecksum } from './settings-sync.js';
+import { migrateConfig } from './config-migrator.js';
+import { validate, formatValidationReport } from './validator.js';
+import { createBackup } from './manifest.js';
+import { TEMPLATES_DIR, ensureDir, cleanEmptyDirs, chmodScripts, writeManifest, generateIndexMd, seedGlobalPrimitives, getPackageVersion, } from './init.js';
+export function runUpdate(projectRoot, options = {}) {
+    const { dryRun = false } = options;
+    const claudeDir = path.join(projectRoot, '.claude');
+    const newVersion = getPackageVersion();
+    console.log(`\nOrbital Command — update${dryRun ? ' (dry run)' : ''}`);
+    console.log(`Project root: ${projectRoot}\n`);
+    // 1. Load or create manifest (auto-migrate legacy installs)
+    let manifest = loadManifest(projectRoot);
+    if (!manifest) {
+        if (needsLegacyMigration(projectRoot)) {
+            console.log('  Migrating from legacy install...');
+            const result = migrateFromLegacy(projectRoot, TEMPLATES_DIR, newVersion);
+            console.log(`  Migrated ${result.synced} synced, ${result.modified} modified, ${result.userOwned} user-owned files`);
+            if (result.importedPins > 0)
+                console.log(`  Imported ${result.importedPins} pinned files from orbital-sync.json`);
+            manifest = loadManifest(projectRoot);
+        }
+        if (!manifest) {
+            console.log('  No manifest found. Run `orbital` first.');
+            return;
+        }
+    }
+    const oldVersion = manifest.packageVersion;
+    // 1b. Refresh file statuses so outdated vs modified is accurate
+    refreshFileStatuses(manifest, claudeDir);
+    // 2. Compute update plan
+    const renameMap = loadRenameMap(TEMPLATES_DIR, oldVersion, newVersion);
+    const plan = computeUpdatePlan({
+        templatesDir: TEMPLATES_DIR,
+        claudeDir,
+        manifest,
+        newVersion,
+        renameMap,
+    });
+    // 3. Dry-run mode — print plan and exit
+    if (dryRun) {
+        console.log(formatPlan(plan, oldVersion, newVersion));
+        return;
+    }
+    if (plan.isEmpty && oldVersion === newVersion) {
+        console.log('  Everything up to date. No changes needed.');
+    }
+    // 4. Create backup of files that will be modified
+    const filesToBackup = getFilesToBackup(plan);
+    if (filesToBackup.length > 0) {
+        const backupDir = createBackup(claudeDir, filesToBackup);
+        if (backupDir) {
+            console.log(`  Backup   ${filesToBackup.length} files → ${path.relative(claudeDir, backupDir)}/`);
+        }
+    }
+    // 5. Execute plan
+    const templateInventory = buildTemplateInventory(TEMPLATES_DIR);
+    // 5a. Handle renames
+    for (const { from, to } of plan.toRename) {
+        const fromPath = path.join(claudeDir, from);
+        const toPath = path.join(claudeDir, to);
+        const toDir = path.dirname(toPath);
+        if (!fs.existsSync(toDir))
+            fs.mkdirSync(toDir, { recursive: true });
+        if (fs.existsSync(fromPath)) {
+            safeBackupFile(fromPath);
+            const stat = fs.lstatSync(fromPath);
+            if (stat.isSymbolicLink()) {
+                const target = fs.readlinkSync(fromPath);
+                fs.unlinkSync(fromPath);
+                fs.symlinkSync(target, toPath);
+            }
+            else {
+                fs.renameSync(fromPath, toPath);
+            }
+        }
+        const record = manifest.files[from];
+        if (record) {
+            delete manifest.files[from];
+            const newHash = templateInventory.get(to);
+            manifest.files[to] = { ...record, templateHash: newHash, installedHash: newHash || record.installedHash };
+        }
+        console.log(`  RENAME  ${from} → ${to}`);
+    }
+    // 5b. Add new files
+    for (const filePath of plan.toAdd) {
+        const templateHash = templateInventory.get(filePath);
+        if (!templateHash)
+            continue;
+        const destPath = path.join(claudeDir, filePath);
+        const destDir = path.dirname(destPath);
+        if (!fs.existsSync(destDir))
+            fs.mkdirSync(destDir, { recursive: true });
+        copyTemplateFile(filePath, destPath);
+        manifest.files[filePath] = templateFileRecord(templateHash);
+        console.log(`  ADD     ${filePath}`);
+    }
+    // 5c. Update changed synced/outdated files
+    for (const filePath of plan.toUpdate) {
+        const templateHash = templateInventory.get(filePath);
+        if (!templateHash)
+            continue;
+        const destPath = path.join(claudeDir, filePath);
+        safeBackupFile(destPath);
+        copyTemplateFile(filePath, destPath);
+        manifest.files[filePath] = templateFileRecord(templateHash);
+        console.log(`  UPDATE  ${filePath}`);
+    }
+    // 5d. Remove deleted files
+    for (const filePath of plan.toRemove) {
+        const absPath = path.join(claudeDir, filePath);
+        if (fs.existsSync(absPath)) {
+            safeBackupFile(absPath);
+            fs.unlinkSync(absPath);
+        }
+        delete manifest.files[filePath];
+        console.log(`  REMOVE  ${filePath}`);
+    }
+    // 5e. Update pinned/modified file records (record new template hash without touching file)
+    for (const { file, reason, newTemplateHash } of plan.toSkip) {
+        if (manifest.files[file]) {
+            manifest.files[file].templateHash = newTemplateHash;
+        }
+        if (reason === 'modified') {
+            console.log(`  SKIP    ${file} (user modified)`);
+        }
+        else {
+            console.log(`  SKIP    ${file} (pinned)`);
+        }
+    }
+    // 5f. Clean up empty directories
+    for (const dir of ['hooks', 'skills', 'agents', 'config/workflows']) {
+        const dirPath = path.join(claudeDir, dir);
+        if (fs.existsSync(dirPath))
+            cleanEmptyDirs(dirPath);
+    }
+    // 6. Bidirectional settings hook sync
+    const settingsTarget = path.join(claudeDir, 'settings.local.json');
+    const settingsSrc = path.join(TEMPLATES_DIR, 'settings-hooks.json');
+    const syncResult = syncSettingsHooks(settingsTarget, settingsSrc, manifest.settingsHooksChecksum, renameMap);
+    if (!syncResult.skipped) {
+        console.log(`  Settings +${syncResult.added} -${syncResult.removed} hooks (${syncResult.updated} renamed)`);
+        manifest.settingsHooksChecksum = getTemplateChecksum(settingsSrc);
+    }
+    // 7. Config migrations
+    const configPath = path.join(claudeDir, 'orbital.config.json');
+    const migrationResult = migrateConfig(configPath, manifest.appliedMigrations);
+    if (migrationResult.applied.length > 0) {
+        manifest.appliedMigrations.push(...migrationResult.applied);
+        console.log(`  Config   ${migrationResult.applied.length} migration(s) applied`);
+    }
+    if (migrationResult.defaultsFilled.length > 0) {
+        console.log(`  Config   ${migrationResult.defaultsFilled.length} default(s) filled`);
+    }
+    // 8. Regenerate derived artifacts (always)
+    const workflowManifestOk = writeManifest(claudeDir);
+    console.log(`  ${workflowManifestOk ? 'Updated' : 'Skipped'}  .claude/config/workflow-manifest.sh`);
+    const indexContent = generateIndexMd(projectRoot, claudeDir);
+    fs.writeFileSync(path.join(claudeDir, 'INDEX.md'), indexContent, 'utf8');
+    console.log(`  Updated  .claude/INDEX.md`);
+    // 9. Update agent-triggers.json (template-managed)
+    const triggersSrc = path.join(TEMPLATES_DIR, 'config', 'agent-triggers.json');
+    const triggersDest = path.join(claudeDir, 'config', 'agent-triggers.json');
+    if (fs.existsSync(triggersSrc)) {
+        fs.copyFileSync(triggersSrc, triggersDest);
+        console.log(`  Updated  .claude/config/agent-triggers.json`);
+    }
+    // 10. Update scope template
+    const scopeTemplateSrc = path.join(TEMPLATES_DIR, 'scopes', '_template.md');
+    const scopeTemplateDest = path.join(projectRoot, 'scopes', '_template.md');
+    if (fs.existsSync(scopeTemplateSrc)) {
+        ensureDir(path.join(projectRoot, 'scopes'));
+        fs.copyFileSync(scopeTemplateSrc, scopeTemplateDest);
+    }
+    // 11. Make hook scripts executable
+    chmodScripts(path.join(claudeDir, 'hooks'));
+    // 12. Refresh global primitives
+    seedGlobalPrimitives();
+    // 13. Update manifest metadata
+    manifest.previousPackageVersion = oldVersion;
+    manifest.packageVersion = newVersion;
+    manifest.updatedAt = new Date().toISOString();
+    saveManifest(projectRoot, manifest);
+    // 14. Validate
+    const report = validate(projectRoot, newVersion);
+    if (report.errors > 0) {
+        console.log(`\n  Validation: ${report.errors} errors found`);
+        console.log(formatValidationReport(report));
+    }
+    const totalChanges = plan.toAdd.length + plan.toUpdate.length + plan.toRemove.length + plan.toRename.length;
+    console.log(`\nUpdate complete. ${totalChanges} file changes, ${plan.toSkip.length} skipped.\n`);
+}
+// ─── Helpers ────────────────────────────────────────────────
+function copyTemplateFile(claudeRelPath, destPath) {
+    const templateRelPath = reverseRemapPath(claudeRelPath);
+    const srcPath = path.join(TEMPLATES_DIR, templateRelPath);
+    if (!fs.existsSync(srcPath)) {
+        throw new Error(`Template file not found: ${templateRelPath}`);
+    }
+    const destDir = path.dirname(destPath);
+    if (!fs.existsSync(destDir))
+        fs.mkdirSync(destDir, { recursive: true });
+    safeCopyTemplate(srcPath, destPath);
+}

package/dist/server/server/utils/cc-hooks-parser.js

@@ -1,4 +1,6 @@
 import { readFileSync } from 'node:fs';
+import { createLogger } from './logger.js';
+const log = createLogger('config');
 const CC_HOOK_EVENTS = ['SessionStart', 'SessionEnd', 'PreToolUse', 'PostToolUse'];
 function extractScriptPath(command) {
     // Strip "$CLAUDE_PROJECT_DIR"/ prefix and quotes
@@ -17,6 +19,7 @@ export function parseCcHooks(settingsPath) {
         raw = readFileSync(settingsPath, 'utf-8');
     }
     catch {
+        log.debug('Settings file not found', { path: settingsPath });
         return [];
     }
     const settings = JSON.parse(raw);

package/dist/server/server/utils/cc-hooks-parser.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { parseCcHooks } from './cc-hooks-parser.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+describe('parseCcHooks', () => {
+    let tmpFile;
+    function writeSettings(data) {
+        tmpFile = path.join(os.tmpdir(), `test-settings-${Date.now()}.json`);
+        fs.writeFileSync(tmpFile, JSON.stringify(data));
+        return tmpFile;
+    }
+    afterEach(() => {
+        if (tmpFile && fs.existsSync(tmpFile))
+            fs.unlinkSync(tmpFile);
+    });
+    it('parses all 4 event types', () => {
+        const file = writeSettings({
+            hooks: {
+                SessionStart: [{ hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/.claude/hooks/init.sh', statusMessage: 'Initializing' }] }],
+                SessionEnd: [{ hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/.claude/hooks/end.sh' }] }],
+                PreToolUse: [{ matcher: 'Edit', hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/.claude/hooks/guard.sh', statusMessage: 'Checking' }] }],
+                PostToolUse: [{ hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/.claude/hooks/log.sh' }] }],
+            },
+        });
+        const hooks = parseCcHooks(file);
+        expect(hooks).toHaveLength(4);
+        expect(hooks.map(h => h.event)).toEqual(['SessionStart', 'SessionEnd', 'PreToolUse', 'PostToolUse']);
+    });
+    it('extracts script path stripping $CLAUDE_PROJECT_DIR', () => {
+        const file = writeSettings({
+            hooks: {
+                SessionStart: [{ hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/.claude/hooks/init-session.sh' }] }],
+            },
+        });
+        const hooks = parseCcHooks(file);
+        expect(hooks[0].scriptPath).toBe('.claude/hooks/init-session.sh');
+        expect(hooks[0].scriptName).toBe('init-session.sh');
+    });
+    it('derives ID from script filename', () => {
+        const file = writeSettings({
+            hooks: {
+                SessionStart: [{ hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/.claude/hooks/init-session.sh' }] }],
+            },
+        });
+        const hooks = parseCcHooks(file);
+        expect(hooks[0].id).toBe('init-session');
+    });
+    it('extracts matcher from group', () => {
+        const file = writeSettings({
+            hooks: {
+                PreToolUse: [{ matcher: 'Edit', hooks: [{ type: 'command', command: 'test.sh' }] }],
+            },
+        });
+        const hooks = parseCcHooks(file);
+        expect(hooks[0].matcher).toBe('Edit');
+    });
+    it('sets matcher to null when absent', () => {
+        const file = writeSettings({
+            hooks: {
+                SessionStart: [{ hooks: [{ type: 'command', command: 'test.sh' }] }],
+            },
+        });
+        const hooks = parseCcHooks(file);
+        expect(hooks[0].matcher).toBeNull();
+    });
+    it('skips non-command entries', () => {
+        const file = writeSettings({
+            hooks: {
+                SessionStart: [{ hooks: [
+                            { type: 'command', command: 'test.sh' },
+                            { type: 'url', command: 'https://example.com' },
+                        ] }],
+            },
+        });
+        const hooks = parseCcHooks(file);
+        expect(hooks).toHaveLength(1);
+    });
+    it('returns empty array for file not found', () => {
+        expect(parseCcHooks('/tmp/nonexistent-settings.json')).toEqual([]);
+    });
+    it('returns empty array when no hooks key in settings', () => {
+        const file = writeSettings({ other: 'config' });
+        expect(parseCcHooks(file)).toEqual([]);
+    });
+});