hippo-memory 1.60.0 → 1.62.0

package/dist/cli/hook-blocks.js

@@ -0,0 +1,233 @@
+// The hippo block each agent's instruction file carries, and how init recognises one it wrote earlier.
+import { createHash } from 'node:crypto';
+export const HOOK_MARKERS = {
+    start: '<!-- hippo:start -->',
+    end: '<!-- hippo:end -->',
+};
+export const HOOKS = {
+    'claude-code': {
+        file: 'CLAUDE.md',
+        description: 'Claude Code',
+        content: `
+## Project Memory (Hippo)
+
+Pinned rules and recent writes auto-inject at every prompt via the installed
+UserPromptSubmit hook; never re-run that part manually. At the START of a
+task (not per prompt), additionally load task-specific context: git-aware
+recall over the full store that per-prompt injection does not cover. Also
+run it if the hook is not installed:
+\`\`\`bash
+hippo context --auto --budget 1500
+\`\`\`
+
+When you find out why something failed, record it right then, while you
+work, never as a closing step:
+\`\`\`bash
+hippo remember "<what went wrong and why>" --error
+\`\`\`
+
+The installed hooks store failed tool calls and capture the session when it
+ends, so there is nothing to run before you finish.
+`.trim(),
+    },
+    'codex': {
+        file: 'AGENTS.md',
+        description: 'OpenAI Codex',
+        content: `
+## Project Memory (Hippo)
+
+At the start of every task, run:
+\`\`\`bash
+hippo context --auto --budget 1500
+\`\`\`
+Read the output before writing any code.
+
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
+\`\`\`bash
+hippo remember "<description of what went wrong>" --error
+\`\`\`
+
+When you learn something that should outlive this session (a decision and
+its reason, a user preference, a lesson), record it right then, while you
+work, never as a closing step. Leave out secrets and personal details:
+\`\`\`bash
+hippo remember "<what you learned and why>"
+\`\`\`
+
+When Hippo's Codex wrapper is installed, session-end capture runs automatically.
+If the wrapper is not installed, capture a brief summary manually:
+\`\`\`bash
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
+\`\`\`
+`.trim(),
+    },
+    'cursor': {
+        file: 'AGENTS.md',
+        description: 'Cursor',
+        content: `
+## Project Memory (Hippo)
+
+At the start of every task, run:
+\`\`\`bash
+hippo context --auto --budget 1500
+\`\`\`
+Read the output before writing any code.
+
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
+\`\`\`bash
+hippo remember "<description of what went wrong>" --error
+\`\`\`
+
+When you learn something that should outlive this session (a decision and
+its reason, a user preference, a lesson), record it right then, while you
+work, never as a closing step. Leave out secrets and personal details:
+\`\`\`bash
+hippo remember "<what you learned and why>"
+\`\`\`
+
+When ending a session, capture a brief summary:
+\`\`\`bash
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
+\`\`\`
+`.trim(),
+    },
+    'openclaw': {
+        file: 'AGENTS.md',
+        description: 'OpenClaw',
+        content: `
+## Project Memory (Hippo)
+
+At the start of every session, run:
+\`\`\`bash
+hippo context --auto --budget 1500
+\`\`\`
+Read the output before writing any code.
+
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
+\`\`\`bash
+hippo remember "<description of what went wrong>" --error
+\`\`\`
+
+When you learn something that should outlive this session (a decision and
+its reason, a user preference, a lesson), record it right then, while you
+work, never as a closing step. Leave out secrets and personal details:
+\`\`\`bash
+hippo remember "<what you learned and why>"
+\`\`\`
+
+When ending a session, capture a brief summary:
+\`\`\`bash
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
+\`\`\`
+`.trim(),
+    },
+    'opencode': {
+        file: 'AGENTS.md',
+        description: 'OpenCode',
+        content: `
+## Project Memory (Hippo)
+
+At the start of every task, run:
+\`\`\`bash
+hippo context --auto --budget 1500
+\`\`\`
+Read the output before writing any code.
+
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
+\`\`\`bash
+hippo remember "<description of what went wrong>" --error
+\`\`\`
+
+When you learn something that should outlive this session (a decision and
+its reason, a user preference, a lesson), record it right then, while you
+work, never as a closing step. Leave out secrets and personal details:
+\`\`\`bash
+hippo remember "<what you learned and why>"
+\`\`\`
+
+When stuck or repeating yourself, check if this happened before:
+\`\`\`bash
+hippo recall "<what's going wrong>" --budget 2000
+\`\`\`
+
+When ending a session, capture a brief summary:
+\`\`\`bash
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
+\`\`\`
+`.trim(),
+    },
+    'pi': {
+        file: 'AGENTS.md',
+        description: 'Pi',
+        content: `
+## Project Memory (Hippo)
+
+At the start of every session, run:
+\`\`\`bash
+hippo context --auto --budget 1500
+\`\`\`
+Read the output before writing any code.
+
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
+\`\`\`bash
+hippo remember "<description of what went wrong>" --error
+\`\`\`
+
+When you learn something that should outlive this session (a decision and
+its reason, a user preference, a lesson), record it right then, while you
+work, never as a closing step. Leave out secrets and personal details:
+\`\`\`bash
+hippo remember "<what you learned and why>"
+\`\`\`
+
+When ending a session, capture a brief summary:
+\`\`\`bash
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
+\`\`\`
+
+For full integration, copy the hippo-memory Pi extension to \`~/.pi/agent/extensions/hippo-memory/\`.
+`.trim(),
+    },
+};
+// sha256 of each trimmed block an earlier hippo wrote, so init refreshes only blocks nobody edited. Add the old hash when a block changes.
+const SHIPPED_HOOK_HASHES = new Map([
+    ['c04e48f2896a4fee9ae98f8f832e2d26a3910269df3beb5bcd6baee3cd9db68e', 'claude-code'],
+    ['e6b12bd8983c032e5ca8e95a97aeff4178a5a05026d10acad5b2e1b25d5656dd', 'claude-code'],
+    ['4c64e11d3e5be68fa547c9248d7553feb645a02f7cf13ba02f7275e1854baf44', 'claude-code'],
+    ['293bd319bbc86225a0ee027490a3322a0336257f5832f7fade65e4ffb2530654', 'claude-code'],
+    ['15abcece9712279fb4721f7a8f0ba117457400278977beb5cf5b5d7ba49f7b1a', 'codex'],
+    ['0c81a6b2c21473313001f624b80ea870e661aecbfda9bfe8503febc0d5f34533', 'codex'],
+    ['88e45358aba4f17912f113221c991dc758275991335d1daa4aa1974a69c46769', 'codex'],
+    ['e61632fe177450a06541c148a9a4f9182530d8df667806927a99792825903298', 'codex'],
+    ['a1415ecda9b2f8f317c233738e4a5ac16e6b2cc385a017c0c8ecfbfacbcab6a3', 'cursor'],
+    ['a38c428bbdfc14ec50f6f7b9183785170a4eae1ce9cde60257cca6efc7206b3a', 'cursor'],
+    ['0ec9f556abfd55e94f9e6fb47ece0fc5acb841977d144b35a2371e03645d8636', 'cursor'],
+    ['40524c3bd5a2eb04036567cc761451961d950995768bccd93a9900b0f75eafea', 'openclaw'],
+    ['7b3518e8c0feaa7b8b454cde7743f7598ad14cd9979e1680d0954484e2464aae', 'openclaw'],
+    ['1137dcf04568caf011e41db77bc55324faee88bc29c3a5fcc98ab687cd952a16', 'openclaw'],
+    ['4601c67c31f41cd5b1324cfccdb1afc66872b7fb0bc1e7c5789ecabb1f6bd942', 'opencode'],
+    ['90d9e21d8d1ecbe99a0fc7b7f2d9f8af7b5315a6b4b0203df4f7a9bdc0699b98', 'opencode'],
+    ['ca4e00284f1397ed2f2fcc53210c27f63b90edf6b37fd66dad5ee58b94ea3eee', 'opencode'],
+    ['8b8f5986d7f7ed15f06e68720d8913c3cab23d94366b411935ca2bbaa334553b', 'pi'],
+    ['37767b355e18beac726b05b9e2b898dab8c6135fd7b98f3aa52edc734d5dd283', 'pi'],
+    ['6e85a5cccb3cfeaa9a080713754936db730f96376f94cc9a9888a746149c7268', 'pi'],
+]);
+/** The first hippo block in `text` and the agent whose current or shipped text it is; `owner` is undefined for an edited block. */
+export function hippoBlock(text) {
+    const at = text.indexOf(HOOK_MARKERS.start);
+    const start = at + HOOK_MARKERS.start.length;
+    const end = text.indexOf(HOOK_MARKERS.end, start);
+    if (at < 0 || end < 0)
+        return null;
+    // git autocrlf checks these files out with CRLF: match as LF, write back in the file's own ending.
+    const raw = text.slice(start, end);
+    const inner = raw.replace(/\r\n/g, '\n').trim();
+    const owner = Object.keys(HOOKS).find((k) => HOOKS[k].content === inner) ?? SHIPPED_HOOK_HASHES.get(createHash('sha256').update(inner).digest('hex'));
+    return { start, end, eol: raw.includes('\r\n') ? '\r\n' : '\n', inner, owner };
+}
+//# sourceMappingURL=hook-blocks.js.map

package/dist/cli/init.d.ts

@@ -0,0 +1,2 @@
+export declare function cmdInit(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/init.js

@@ -0,0 +1,305 @@
+// `hippo init`: create a store and wire the detected agents' instruction files, hooks and daily runner.
+import { envSkipAutoIntegrations } from '../env.js';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { installJsonHooks } from '../hooks/json-hooks.js';
+import { isCodexPresent } from '../hooks/shared.js';
+import { isCodexWrapperInstalled } from '../hooks/codex-wrapper.js';
+import { installOpencodePlugin } from '../hooks/opencode.js';
+import { isInitialized, initStore } from '../store/open.js';
+import { loadAllEntries } from '../store/entry-reads.js';
+import { isGitRepo } from '../autolearn.js';
+import { currentMachine, importForStore, importProjectMemories, importUserMemories } from '../agent-memories/sync.js';
+import { emptyReport, mergeReports } from '../agent-memories/report.js';
+import { getGlobalRoot, initGlobal } from '../shared.js';
+import { registerWorkspace } from '../scheduler.js';
+import { printAgentImport, installCodexMemoryHooks, setupDailySchedule, learnFromRepo } from './shared.js';
+import { HOOK_MARKERS, HOOKS, hippoBlock } from './hook-blocks.js';
+function scanForGitRepos(rootDir, maxDepth = 2) {
+    const repos = [];
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.'))
+                    continue;
+                const full = path.join(dir, entry.name);
+                if (fs.existsSync(path.join(full, '.git'))) {
+                    repos.push(full);
+                }
+                if (depth < maxDepth)
+                    walk(full, depth + 1);
+            }
+        }
+        catch { /* permission denied, etc */ }
+    }
+    // Check if rootDir itself is a git repo
+    if (fs.existsSync(path.join(rootDir, '.git')))
+        repos.push(rootDir);
+    walk(rootDir, 0);
+    return repos;
+}
+function cmdInitScan(scanDir, flags) {
+    const resolved = path.resolve(scanDir);
+    console.log(`Scanning ${resolved} for git repositories...\n`);
+    const repos = scanForGitRepos(resolved);
+    if (repos.length === 0) {
+        console.log('No git repositories found.');
+        return;
+    }
+    console.log(`Found ${repos.length} repositories:\n`);
+    // Init global store first
+    const globalRoot = getGlobalRoot();
+    if (!isInitialized(globalRoot)) {
+        initGlobal();
+        console.log(`Initialized global store at ${globalRoot}\n`);
+    }
+    let totalLessons = 0;
+    // Rolled up so the cross-repo summary reports the gate too. Each repo
+    // already prints its own count inside learnFromRepo, but the aggregate
+    // line showed only what was ADDED - and the point of this change is
+    // that a dropped subject is never invisible.
+    let totalLowInfo = 0;
+    const seedDays = parseInt(String(flags['days'] ?? '365'), 10);
+    const machine = currentMachine();
+    const agentImport = emptyReport();
+    for (const repo of repos) {
+        const name = path.basename(repo);
+        const repoHippo = path.join(repo, '.hippo');
+        const alreadyExists = isInitialized(repoHippo);
+        if (!alreadyExists) {
+            initStore(repoHippo);
+        }
+        registerWorkspace(globalRoot, repo);
+        // Learn from git history
+        let added = 0;
+        if (!flags['no-learn'] && isGitRepo(repo)) {
+            const result = learnFromRepo(repoHippo, repo, seedDays, name);
+            added = result.added;
+            totalLessons += added;
+            totalLowInfo += result.lowInfo;
+        }
+        if (!flags['no-learn'])
+            mergeReports(agentImport, importProjectMemories(repoHippo, { machine }));
+        const status = alreadyExists ? 'existing' : 'new';
+        const entries = loadAllEntries(repoHippo);
+        console.log(`  ${name.padEnd(25)} ${status.padEnd(10)} ${entries.length} memories${added > 0 ? ` (+${added} from git)` : ''}`);
+    }
+    console.log(`\n${repos.length} repositories, ${totalLessons} new lessons learned` +
+        (totalLowInfo > 0 ? `, ${totalLowInfo} low-information subject(s) dropped` : '') +
+        '.');
+    if (!flags['no-learn']) {
+        mergeReports(agentImport, importUserMemories(globalRoot, { machine }));
+        printAgentImport(agentImport, '');
+    }
+    console.log(`Global store: ${globalRoot}`);
+    if (initInstallsIntegrations(flags)) {
+        // User-level hooks only: a hippo block in each repo's CLAUDE.md or AGENTS.md would leave a diff in every repo.
+        const agents = detectAgentHooks(repos);
+        if (agents.length === 0) {
+            console.log('   No agent config found in these repositories. Run `hippo setup` to add hooks for the agents on this machine.');
+        }
+        installUserLevelHooks(agents, true);
+    }
+    if (!flags['no-schedule']) {
+        setupDailySchedule(globalRoot);
+    }
+    console.log(`\nRun \`hippo sleep\` in any project to consolidate and auto-share to global.`);
+}
+export function cmdInit(hippoRoot, flags) {
+    // Handle --scan mode
+    if (flags['scan']) {
+        const scanDir = typeof flags['scan'] === 'string' ? flags['scan'] : os.homedir();
+        cmdInitScan(scanDir, flags);
+        return;
+    }
+    if (flags['global']) {
+        const globalRoot = getGlobalRoot();
+        if (isInitialized(globalRoot)) {
+            console.log('Already initialized global store at', globalRoot);
+        }
+        else {
+            initGlobal();
+            console.log('Initialized global Hippo store at', globalRoot);
+        }
+        if (!flags['no-learn'])
+            printAgentImport(importUserMemories(globalRoot, { machine: currentMachine() }));
+        return;
+    }
+    const alreadyExists = isInitialized(hippoRoot);
+    if (alreadyExists) {
+        console.log('Already initialized at', hippoRoot);
+    }
+    else {
+        initStore(hippoRoot);
+        console.log('Initialized Hippo at', hippoRoot);
+        console.log('   Directories: buffer/ episodic/ semantic/ conflicts/');
+        console.log('   Files: hippo.db stats.json');
+    }
+    const globalRoot = getGlobalRoot();
+    registerWorkspace(globalRoot, path.dirname(hippoRoot));
+    if (initInstallsIntegrations(flags)) {
+        autoInstallHooks();
+    }
+    // Auto-setup daily schedule (unless --no-schedule)
+    if (!flags['no-schedule'] && !flags['global']) {
+        setupDailySchedule(globalRoot);
+    }
+    // Seed with git history on first init (unless --no-learn)
+    if (!alreadyExists && !flags['no-learn'] && !flags['global']) {
+        if (isGitRepo(process.cwd())) {
+            const seedDays = 30;
+            console.log(`\n   Seeding memories from last ${seedDays} days of git history...`);
+            const { added, skipped } = learnFromRepo(hippoRoot, process.cwd(), seedDays);
+            if (added > 0) {
+                console.log(`   Learned ${added} lessons from git (${skipped} duplicates skipped).`);
+            }
+            else {
+                console.log(`   No matching commits found in git history.`);
+            }
+        }
+    }
+    // Every run, not only the first: an agent's notes change between inits.
+    if (!flags['no-learn'])
+        printAgentImport(importForStore(hippoRoot, { machine: currentMachine() }));
+}
+/** Every write init makes into agent config (instruction blocks, hooks, plugins) is an automatic integration, so one switch skips them all. */
+function initInstallsIntegrations(flags) {
+    if (flags['no-hooks'])
+        return false;
+    if (!envSkipAutoIntegrations())
+        return true;
+    console.log('   HIPPO_SKIP_AUTO_INTEGRATIONS=1, so init left agent instruction files and hooks alone.');
+    return false;
+}
+/** Plain init: patch the detected agents' instruction files in cwd, then install their user-level hooks. */
+function autoInstallHooks() {
+    const cwd = process.cwd();
+    const agents = detectAgentHooks([cwd]);
+    const agentsMd = path.join(cwd, HOOKS.codex.file);
+    // Read before patching: a re-run of init finds its own block and skips the Codex hint.
+    const codexHint = !(fs.existsSync(agentsMd) && fs.readFileSync(agentsMd, 'utf8').includes(HOOK_MARKERS.start));
+    patchInstructionFiles(cwd, agents);
+    installUserLevelHooks(agents, codexHint);
+}
+/** HOOKS keys of the agents with a marker file in any of dirs, in detector order. */
+function detectAgentHooks(dirs) {
+    // Map: filename to check -> hook key(s) to install
+    const detectors = [
+        { files: ['CLAUDE.md', '.claude/settings.json'], hook: 'claude-code' },
+        { files: ['AGENTS.md', '.codex'], hook: 'codex' },
+        // No Cursor row: Cursor reads the root AGENTS.md, which the rows either side patch.
+        { files: ['.openclaw', 'AGENTS.md'], hook: 'openclaw' },
+        { files: ['.opencode', 'opencode.json'], hook: 'opencode' },
+        { files: ['.pi', '.pi/agent'], hook: 'pi' },
+    ];
+    return detectors
+        .filter(({ files }) => dirs.some((dir) => files.some((f) => fs.existsSync(path.join(dir, f)))))
+        .map(({ hook }) => hook);
+}
+function patchInstructionFiles(dir, agents) {
+    // One block per file: several agents share AGENTS.md.
+    const seen = new Set();
+    for (const hook of agents) {
+        const hookDef = HOOKS[hook];
+        if (!hookDef)
+            continue;
+        const targetPath = path.resolve(dir, hookDef.file);
+        // Never create the file: a marker such as .codex or .claude/settings.json does not ask for a new AGENTS.md or CLAUDE.md.
+        if (!fs.existsSync(targetPath) || seen.has(targetPath))
+            continue;
+        seen.add(targetPath);
+        const existing = fs.readFileSync(targetPath, 'utf8');
+        if (existing.includes(HOOK_MARKERS.start)) {
+            refreshShippedBlock(targetPath, existing, hook);
+            continue;
+        }
+        const block = `${HOOK_MARKERS.start}\n${hookDef.content}\n${HOOK_MARKERS.end}`;
+        const sep = existing.endsWith('\n') ? '\n' : '\n\n';
+        fs.writeFileSync(targetPath, existing + sep + block + '\n', 'utf8');
+        console.log(`   Auto-installed ${hook} hook in ${hookDef.file}`);
+    }
+}
+/** Swap an unedited block from an earlier hippo for the current one; an edited block stays, with a hint. */
+function refreshShippedBlock(filePath, text, hook) {
+    const block = hippoBlock(text);
+    if (!block || (block.owner && HOOKS[block.owner].content === block.inner))
+        return;
+    const { start, end, eol, owner } = block;
+    const name = path.basename(filePath);
+    if (!owner) {
+        console.log(`   Left the edited hippo block in ${name} as is; \`hippo hook install ${hook}\` replaces it.`);
+        return;
+    }
+    fs.writeFileSync(filePath, `${text.slice(0, start)}${eol}${HOOKS[owner].content.replace(/\n/g, eol)}${eol}${text.slice(end)}`, 'utf8');
+    console.log(`   Refreshed the ${owner} hippo block in ${name}`);
+}
+/** Claude Code settings hooks, Codex's hooks.json and the OpenCode plugin, under the home directory; idempotent, so re-running init adds newer hooks. */
+function installUserLevelHooks(agents, codexHint) {
+    for (const hook of agents) {
+        // The Codex capture wrapper swaps the codex launcher binary, so init only points at the opt-in (issue #133).
+        if (hook === 'codex' && codexHint && !isCodexWrapperInstalled()) {
+            console.log('   Codex detected. To capture Codex sessions: hippo hook install codex');
+        }
+        // Checked first so init never creates ~/.codex on a machine without Codex.
+        if (hook === 'codex' && isCodexPresent())
+            installCodexMemoryHooks('   ');
+        // For Claude Code, also install SessionEnd+SessionStart entries in its
+        // settings.json. Keeps `hippo init` in lockstep with `hippo hook install
+        // claude-code` and `hippo setup`.
+        if (hook === 'claude-code') {
+            const result = installJsonHooks(hook);
+            if (result.installedSessionEnd) {
+                console.log(`   Auto-installed hippo session-end SessionEnd hook in ${hook} settings`);
+            }
+            if (result.installedSessionStart) {
+                console.log(`   Auto-installed hippo last-sleep SessionStart hook in ${hook} settings`);
+            }
+            if (result.installedUserPromptSubmit) {
+                console.log(`   Auto-installed hippo pinned-inject UserPromptSubmit hook in ${hook} settings`);
+            }
+            if (result.installedPreCompact) {
+                console.log(`   Auto-installed hippo pre-compact PreCompact hook in ${hook} settings`);
+            }
+            if (result.installedCompactResume) {
+                console.log(`   Auto-installed hippo compact-resume SessionStart(compact) hook in ${hook} settings`);
+            }
+            if (result.installedPostCompact) {
+                console.log(`   Auto-installed hippo post-compact PostCompact hook in ${hook} settings`);
+            }
+            if (result.installedCaptureError) {
+                console.log(`   Auto-installed hippo capture-error PostToolUseFailure hook in ${hook} settings`);
+            }
+            if (result.migratedFromStop) {
+                console.log(`   Migrated legacy Stop hook → SessionEnd (no longer runs every turn)`);
+            }
+            if (result.migratedSplitSessionEnd) {
+                console.log(`   Migrated split sleep+capture SessionEnd entries → single detached hippo session-end`);
+            }
+            else if (result.migratedLegacySessionEnd) {
+                console.log(`   Migrated legacy SessionEnd entry to the new detached form`);
+            }
+        }
+        else if (hook === 'opencode') {
+            // opencode uses a TS plugin, not Claude Code's JSON-hook schema.
+            // See OPENCODE_PLUGIN_SOURCE in src/hooks.ts for the plugin file
+            // content + design rationale.
+            const result = installOpencodePlugin();
+            if (result.installed) {
+                console.log(`   Auto-installed hippo opencode plugin -> ${result.pluginPath}`);
+            }
+            if (result.migratedLegacyHooks) {
+                console.log(`   Removed legacy Claude Code-style hooks block from opencode.json — opencode can now launch`);
+            }
+            if (result.jsonRepairFailed) {
+                console.log(`   WARNING: opencode.json is unparseable; legacy hooks block could not be auto-removed. Fix the file manually.`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/maintenance.d.ts

@@ -0,0 +1,4 @@
+export declare function cmdRefine(hippoRoot: string, flags: Record<string, string | boolean | string[]>): Promise<void>;
+export declare function cmdDedup(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
+export declare function cmdEmbed(hippoRoot: string, flags: Record<string, string | boolean | string[]>): Promise<void>;
+//# sourceMappingURL=maintenance.d.ts.map