Skip to content

Local-first 🧠 memory for Hermes Agent that lives in your Obsidian vault and remembers project context. Nightly 😴 dream passes turn repeat corrections into confirmed preferences with measurable confidence. Adapters ship for Claude Code, Codex, and OpenClaw, with an MCP server for anything else.

TypeScript
17.4 KB
Raw Blame
/**
 * `o2b brain` subcommand dispatcher.
 *
 * Routes Brain verbs to thin wrappers over `src/core/brain/*`.
 * Each verb handler lives in `./verbs/<name>.ts`; this file only
 * dispatches and prints help.
 */

import { CliError } from "./argparse.ts";
import { BRAIN_HELP, VERB_HELP } from "./brain/helpers.ts";
import {
  cmdBrainInit,
  cmdBrainFeedback,
  cmdBrainNote,
  cmdBrainLifecycle,
  cmdBrainNoteLifecycle,
  cmdBrainScaffoldStub,
  cmdBrainClaims,
  cmdBrainDecision,
  cmdBrainTension,
  cmdBrainDream,
  cmdBrainApplyEvidence,
  cmdBrainLessons,
  cmdBrainDigest,
  cmdBrainIntentReview,
  cmdBrainRetention,
  cmdBrainMonthly,
  cmdBrainQuery,
  cmdBrainAgentQuery,
  cmdBrainAgentDiff,
  cmdBrainWrites,
  cmdBrainReject,
  cmdBrainFreeze,
  cmdBrainPin,
  cmdBrainUnfreeze,
  handleBrainLogSubcommand,
  cmdBrainAttest,
  cmdBrainUnpin,
  cmdBrainState,
  cmdBrainSetPrimary,
  cmdBrainProtect,
  cmdBrainUnprotect,
  cmdBrainRollback,
  cmdBrainDoctor,
  cmdBrainHygiene,
  cmdBrainRefresh,
  cmdBrainAnticipate,
  cmdBrainWatchdog,
  cmdBrainHealth,
  cmdBrainHealthBaseline,
  cmdBrainStatus,
  cmdBrainHistory,
  cmdBrainActivation,
  cmdBrainTruth,
  cmdBrainFacts,
  cmdBrainDeadEnd,
  cmdBrainForesight,
  cmdBrainLabel,
  cmdBrainBridges,
  cmdBrainClusters,
  cmdBrainVitals,
  cmdBrainCoOccurrence,
  cmdBrainHallways,
  cmdBrainFileContext,
  cmdBrainBenchmark,
  cmdBrainTune,
  cmdBrainAttr,
  cmdBrainTiers,
  cmdBrainSecret,
  cmdBrainMaintenance,
  cmdBrainAudit,
  cmdBrainMorningBrief,
  cmdBrainCodec,
  cmdBrainSources,
  cmdBrainSchema,
  cmdBrainSettings,
  cmdBrainGraphExport,
  cmdBrainGraphImport,
  cmdBrainBankExport,
  cmdBrainBankImport,
  cmdBrainBacklinks,
  cmdBrainSemanticsBackfill,
  cmdBrainAuthoredAtBackfill,
  cmdBrainPrivacyMarkerRestamp,
  cmdBrainMcpLandscape,
  cmdBrainMerge,
  cmdBrainExplorer,
  cmdBrainExport,
  cmdBrainOkfExport,
  cmdBrainOkfImport,
  cmdBrainKnowledgePack,
  cmdBrainUpgrade,
  handleBrainSnapshotSubcommand,
  cmdBrainScanInline,
  cmdBrainScanCitations,
  cmdBrainEntity,
  cmdBrainImportSession,
  cmdBrainForgetSource,
  cmdBrainBatchPlan,
  cmdBrainPreExtract,
  runBrainExtract,
  cmdBrainDistill,
  cmdBrainHandoff,
  cmdBrainIntention,
  cmdBrainProject,
  cmdBrainSource,
  cmdBrainLinks,
  cmdBrainProfile,
  cmdBrainSgrep,
  cmdBrainContinuity,
  cmdBrainPayload,
  cmdBrainReceipts,
  cmdBrainStorage,
  cmdBrainChanges,
  cmdBrainMigrateStore,
  cmdBrainSessionSummary,
  cmdBrainIdeaLineage,
  cmdBrainNoteHistory,
  cmdBrainBench,
  cmdBrainGit,
  cmdBrainArchitect,
  cmdBrainSession,
  cmdBrainPanel,
  cmdBrainTrigger,
  cmdBrainDeepSynthesis,
  cmdBrainDiarize,
  cmdBrainExtractSignals,
  cmdBrainDeadLetters,
  cmdBrainDesignNote,
  cmdBrainIdeas,
  cmdBrainSessionHook,
  cmdBrainImportClaudeMemory,
  cmdBrainPageDedup,
  cmdBrainTokenFootprint,
  cmdBrainContextPack,
  cmdBrainContextReceipts,
  cmdBrainEventTrace,
  cmdBrainContextPresets,
  cmdBrainPreCompactExtract,
  cmdBrainPostCompactAudit,
  cmdBrainRecallTelemetry,
  cmdBrainKnowledgeGaps,
  cmdBrainGenerationReports,
  cmdBrainSkillProposals,
  cmdBrainProceduralMemory,
  cmdBrainProceduralGraph,
  cmdBrainRecurrence,
  cmdBrainObligation,
  cmdBrainAgenda,
  cmdBrainToday,
  cmdBrainApplyMarkers,
  cmdBrainPending,
  cmdBrainCapture,
  cmdBrainExpire,
  cmdBrainTelegramCapture,
  cmdBrainInboxDrain,
  cmdBrainRepairLane,
  cmdBrainOrphanRepair,
  cmdBrainSignal,
  cmdBrainAttentionFlows,
  cmdBrainSessionDescribe,
  cmdBrainSessionExpand,
  cmdBrainSessionGrep,
  cmdBrainLint,
  cmdBrainValidate,
  cmdBrainActions,
  cmdBrainSummary,
  cmdBrainUnlinked,
  cmdBrainSynthesise,
  cmdBrainMocAudit,
  cmdBrainTimeline,
  cmdBrainEvolution,
  cmdBrainStale,
  cmdBrainDaily,
  cmdBrainWeekly,
  cmdBrainPermissions,
} from "./brain/verbs/index.ts";

/**
 * Brain verbs whose whole purpose is replaying records authored
 * somewhere else, spelled as the verb path the caller types. The CLI
 * entry point reads this to claim the `import` origin channel for the
 * process (`src/core/origin-channel.ts`) instead of the `cli` every
 * other verb gets.
 *
 * It lives here, beside the `switch` that dispatches these verbs, so a
 * renamed verb moves both in one edit; a copy of the list in `main.ts`
 * would be a copy that goes stale the first time one is renamed.
 *
 * Membership is "replays records this operator did not author now",
 * which is why `scan-inline` is absent: it captures `@osb` markers the
 * operator wrote in their own vault during this session, and that is a
 * `cli` capture wearing an unusual input format.
 */
export const BRAIN_IMPORT_VERB_PATHS: ReadonlyArray<string> = Object.freeze([
  "bank-import",
  "git ingest",
  "graph-import",
  "import-claude-memory",
  "import-session",
  "knowledge-pack install",
]);

/**
 * Whether `o2b brain <argv…>` names one of {@link BRAIN_IMPORT_VERB_PATHS}.
 * Matches on the first two words so a nested verb (`git ingest`) is
 * distinguishable from its read-only siblings (`git status`, `git find`).
 */
export function isBrainImportVerb(argv: ReadonlyArray<string>): boolean {
  if (argv.length === 0) return false;
  const one = argv[0]!;
  const two = argv.length > 1 ? `${one} ${argv[1]!}` : one;
  return BRAIN_IMPORT_VERB_PATHS.includes(one) || BRAIN_IMPORT_VERB_PATHS.includes(two);
}

export async function handleBrainSubcommand(argv: ReadonlyArray<string>): Promise<number> {
  if (argv.length === 0 || argv[0] === "-h" || argv[0] === "--help") {
    process.stdout.write(BRAIN_HELP);
    return argv.length === 0 ? 2 : 0;
  }
  const verb = argv[0]!;
  const rest = argv.slice(1);

  if (rest.length === 1 && (rest[0] === "-h" || rest[0] === "--help")) {
    const text = VERB_HELP[verb];
    if (text) {
      process.stdout.write(text);
      return 0;
    }
    process.stdout.write(BRAIN_HELP);
    return 2;
  }

  try {
    switch (verb) {
      case "init":
        return await cmdBrainInit(rest);
      case "feedback":
        return await cmdBrainFeedback(rest);
      case "note":
        return await cmdBrainNote(rest);
      case "lifecycle":
        return await cmdBrainLifecycle(rest);
      case "expire":
        return await cmdBrainExpire(rest);
      case "note-lifecycle":
        return await cmdBrainNoteLifecycle(rest);
      case "scaffold-stub":
        return await cmdBrainScaffoldStub(rest);
      case "claims":
        return await cmdBrainClaims(rest);
      case "decision":
        return await cmdBrainDecision(rest);
      case "tension":
        return await cmdBrainTension(rest);
      case "dream":
        return await cmdBrainDream(rest);
      case "apply-evidence":
        return await cmdBrainApplyEvidence(rest);
      case "digest":
        return await cmdBrainDigest(rest);
      case "intent-review":
        return await cmdBrainIntentReview(rest);
      case "retention":
        return await cmdBrainRetention(rest);
      case "monthly":
        return await cmdBrainMonthly(rest);
      case "query":
        return await cmdBrainQuery(rest);
      case "agent-query":
        return await cmdBrainAgentQuery(rest);
      case "agent-diff":
        return await cmdBrainAgentDiff(rest);
      case "writes":
        return await cmdBrainWrites(rest);
      case "reject":
        return await cmdBrainReject(rest);
      case "freeze":
        return await cmdBrainFreeze(rest);
      case "unfreeze":
        return await cmdBrainUnfreeze(rest);
      case "log":
        return await handleBrainLogSubcommand(rest);
      case "attest":
        return await cmdBrainAttest(rest);
      case "pin":
        return await cmdBrainPin(rest);
      case "unpin":
        return await cmdBrainUnpin(rest);
      case "lessons":
        return await cmdBrainLessons(rest);
      case "state":
        return await cmdBrainState(rest);
      case "set-primary":
        return await cmdBrainSetPrimary(rest);
      case "protect":
        return await cmdBrainProtect(rest);
      case "unprotect":
        return await cmdBrainUnprotect(rest);
      case "snapshot":
        return await handleBrainSnapshotSubcommand(rest);
      case "rollback":
        return await cmdBrainRollback(rest);
      case "doctor":
        return await cmdBrainDoctor(rest);
      case "hygiene":
        return await cmdBrainHygiene(rest);
      case "refresh":
        return await cmdBrainRefresh(rest);
      case "anticipate":
        return await cmdBrainAnticipate(rest);
      case "watchdog":
        return await cmdBrainWatchdog(rest);
      case "health":
        return await cmdBrainHealth(rest);
      case "health-baseline":
        return await cmdBrainHealthBaseline(rest);
      case "status":
        return await cmdBrainStatus(rest);
      case "history":
        return await cmdBrainHistory(rest);
      case "activation":
        return await cmdBrainActivation(rest);
      case "truth":
        return await cmdBrainTruth(rest);
      case "facts":
        return await cmdBrainFacts(rest);
      case "dead-end":
        return await cmdBrainDeadEnd(rest);
      case "foresight":
        return await cmdBrainForesight(rest);
      case "label":
        return await cmdBrainLabel(rest);
      case "bridges":
        return await cmdBrainBridges(rest);
      case "clusters":
        return await cmdBrainClusters(rest);
      case "vitals":
        return await cmdBrainVitals(rest);
      case "co-occurrence":
        return await cmdBrainCoOccurrence(rest);
      case "hallways":
        return await cmdBrainHallways(rest);
      case "file-context":
        return await cmdBrainFileContext(rest);
      case "benchmark":
        return await cmdBrainBenchmark(rest);
      case "tune":
        return await cmdBrainTune(rest);
      case "attr":
        return await cmdBrainAttr(rest);
      case "tiers":
        return await cmdBrainTiers(rest);
      case "secret":
        return await cmdBrainSecret(rest);
      case "maintenance":
        return await cmdBrainMaintenance(rest);
      case "audit":
        return await cmdBrainAudit(rest);
      case "morning-brief":
        return await cmdBrainMorningBrief(rest);
      case "codec":
        return await cmdBrainCodec(rest);
      case "sources":
        return await cmdBrainSources(rest);
      case "schema":
        return await cmdBrainSchema(rest);
      case "settings":
        return await cmdBrainSettings(rest);
      case "graph-export":
        return await cmdBrainGraphExport(rest);
      case "graph-import":
        return await cmdBrainGraphImport(rest);
      case "bank-export":
        return await cmdBrainBankExport(rest);
      case "bank-import":
        return await cmdBrainBankImport(rest);
      case "backlinks":
        return await cmdBrainBacklinks(rest);
      case "semantics-backfill":
        return await cmdBrainSemanticsBackfill(rest);
      case "authored-at-backfill":
        return await cmdBrainAuthoredAtBackfill(rest);
      case "privacy-marker-restamp":
        return await cmdBrainPrivacyMarkerRestamp(rest);
      case "mcp-landscape":
        return await cmdBrainMcpLandscape(rest);
      case "scan-inline":
        return await cmdBrainScanInline(rest);
      case "scan-citations":
        return cmdBrainScanCitations(rest);
      case "import-session":
        return await cmdBrainImportSession(rest);
      case "handoff":
        return await cmdBrainHandoff(rest);
      case "intention":
        return await cmdBrainIntention(rest);
      case "project":
        return await cmdBrainProject(rest);
      case "source":
        return await cmdBrainSource(rest);
      case "forget-source":
        return await cmdBrainForgetSource(rest);
      case "batch-plan":
        return await cmdBrainBatchPlan(rest);
      case "pre-extract":
        return await cmdBrainPreExtract(rest);
      case "extract":
        return await runBrainExtract(rest);
      case "distill":
        return await cmdBrainDistill(rest);
      case "links":
        return await cmdBrainLinks(rest);
      case "profile":
        return await cmdBrainProfile(rest);
      case "sgrep":
        return await cmdBrainSgrep(rest);
      case "continuity":
        return await cmdBrainContinuity(rest);
      case "payload":
        return await cmdBrainPayload(rest);
      case "receipts":
        return await cmdBrainReceipts(rest);
      case "storage":
        return await cmdBrainStorage(rest);
      case "changes":
        return await cmdBrainChanges(rest);
      case "migrate-store":
        return await cmdBrainMigrateStore(rest);
      case "session-summary":
        return await cmdBrainSessionSummary(rest);
      case "idea-lineage":
        return await cmdBrainIdeaLineage(rest);
      case "note-history":
        return await cmdBrainNoteHistory(rest);
      case "bench":
        return await cmdBrainBench(rest);
      case "git":
        return await cmdBrainGit(rest);
      case "architect":
        return await cmdBrainArchitect(rest);
      case "session":
        return await cmdBrainSession(rest);
      case "panel":
        return await cmdBrainPanel(rest);
      case "trigger":
        return await cmdBrainTrigger(rest);
      case "deep-synthesis":
        return await cmdBrainDeepSynthesis(rest);
      case "diarize":
        return await cmdBrainDiarize(rest);
      case "extract-signals":
        return await cmdBrainExtractSignals(rest);
      case "dead-letters":
        return await cmdBrainDeadLetters(rest);
      case "design-note":
        return await cmdBrainDesignNote(rest);
      case "ideas":
        return await cmdBrainIdeas(rest);
      case "entity":
        return await cmdBrainEntity(rest);
      case "session-hook":
        return await cmdBrainSessionHook(rest);
      case "import-claude-memory":
        return await cmdBrainImportClaudeMemory(rest);
      case "merge":
        return await cmdBrainMerge(rest);
      case "upgrade":
        return await cmdBrainUpgrade(rest);
      case "export":
        return await cmdBrainExport(rest);
      case "okf-export":
        return await cmdBrainOkfExport(rest);
      case "okf-import":
        return await cmdBrainOkfImport(rest);
      case "knowledge-pack":
        return await cmdBrainKnowledgePack(rest);
      case "explorer":
        return await cmdBrainExplorer(rest);
      case "page-dedup":
        return await cmdBrainPageDedup(rest);
      case "token-footprint":
        return await cmdBrainTokenFootprint(rest);
      case "context-pack":
        return await cmdBrainContextPack(rest);
      case "context-receipts":
        return await cmdBrainContextReceipts(rest);
      case "event-trace":
        return await cmdBrainEventTrace(rest);
      case "context-presets":
        return await cmdBrainContextPresets(rest);
      case "pre-compact-extract":
        return await cmdBrainPreCompactExtract(rest);
      case "post-compact-audit":
        return await cmdBrainPostCompactAudit(rest);
      case "recall-telemetry":
        return await cmdBrainRecallTelemetry(rest);
      case "knowledge-gaps":
        return await cmdBrainKnowledgeGaps(rest);
      case "generation-reports":
        return await cmdBrainGenerationReports(rest);
      case "skill-proposals":
        return await cmdBrainSkillProposals(rest);
      case "procedural-memory":
        return await cmdBrainProceduralMemory(rest);
      case "procedural-graph":
        return await cmdBrainProceduralGraph(rest);
      case "recurrence":
        return await cmdBrainRecurrence(rest);
      case "attention-flows":
        return await cmdBrainAttentionFlows(rest);
      case "obligation":
        return await cmdBrainObligation(rest);
      case "agenda":
        return await cmdBrainAgenda(rest);
      case "today":
        return await cmdBrainToday(rest);
      case "apply-markers":
        return await cmdBrainApplyMarkers(rest);
      case "pending":
        return await cmdBrainPending(rest);
      case "signal":
        return await cmdBrainSignal(rest);
      case "capture":
        return await cmdBrainCapture(rest);
      case "telegram-capture":
        return await cmdBrainTelegramCapture(rest);
      case "inbox-drain":
        return await cmdBrainInboxDrain(rest);
      case "repair-lane":
        return await cmdBrainRepairLane(rest);
      case "orphan-repair":
        return await cmdBrainOrphanRepair(rest);
      case "session-grep":
        return await cmdBrainSessionGrep(rest);
      case "session-describe":
        return await cmdBrainSessionDescribe(rest);
      case "session-expand":
        return await cmdBrainSessionExpand(rest);
      case "lint":
        return await cmdBrainLint(rest);
      case "validate":
        return await cmdBrainValidate(rest);
      case "actions":
        return await cmdBrainActions(rest);
      case "summary":
        return await cmdBrainSummary(rest);
      case "unlinked":
        return await cmdBrainUnlinked(rest);
      case "synthesise":
        return await cmdBrainSynthesise(rest);
      case "moc-audit":
        return await cmdBrainMocAudit(rest);
      case "timeline":
        return await cmdBrainTimeline(rest);
      case "evolution":
        return await cmdBrainEvolution(rest);
      case "stale":
        return await cmdBrainStale(rest);
      case "daily":
        return await cmdBrainDaily(rest);
      case "weekly":
        return await cmdBrainWeekly(rest);
      case "permissions":
        return await cmdBrainPermissions(rest);
      default:
        process.stderr.write(`error: unknown brain verb: ${verb}\n`);
        process.stdout.write(BRAIN_HELP);
        return 2;
    }
  } catch (exc) {
    if (exc instanceof CliError) {
      process.stderr.write(`error: ${exc.message}\n`);
      return 1;
    }
    throw exc;
  }
}