91 lines
3.3 KiB
TypeScript
91 lines
3.3 KiB
TypeScript
/**
|
|
* Hermes session-start hook — recalls the top-N most relevant frames from
|
|
* personal memory and injects them as additional context for the new Hermes
|
|
* session. Thin entrypoint over the shared SessionStart handler body.
|
|
*
|
|
* Hermes SPLITS SessionStart across two native events, and this ONE compiled
|
|
* script is registered under BOTH (spec §5.4):
|
|
* - `on_session_start` — observer-only (fires once per new session; its
|
|
* return value is ignored by Hermes).
|
|
* - `pre_llm_call` — the inject seam, but ONLY on the first turn.
|
|
*
|
|
* Because the same script fires on every `pre_llm_call` (not just turn 1),
|
|
* it gates on the payload's `is_first_turn` flag: when the host indicates a
|
|
* non-first turn, the script emits nothing (the per-turn save is handled by
|
|
* the separate user-prompt-submit hook). On the first turn (or when the flag
|
|
* is absent — e.g. the `on_session_start` observer payload), it recalls +
|
|
* injects via the hermes adapter's `formatInject` (`{ context: text }`).
|
|
*
|
|
* Fail-open: if hive-mind-cli is unreachable the hook logs and exits 0 with
|
|
* no output — the session starts as it would have without the shim.
|
|
*/
|
|
|
|
import {
|
|
makeSessionStartHandler,
|
|
readStdinAsString,
|
|
runHook,
|
|
safeJsonParse,
|
|
type HookRunOptions,
|
|
} from '@waggle/hive-mind-hooks-core';
|
|
import { hermesAdapter } from '../adapter.js';
|
|
|
|
/**
|
|
* True unless the host explicitly marks this as a non-first turn. Hermes
|
|
* sets `extra.is_first_turn=false` on subsequent `pre_llm_call`s; the
|
|
* `on_session_start` observer payload omits the flag, so absence ⇒ inject.
|
|
*/
|
|
function isFirstTurn(raw: unknown): boolean {
|
|
if (raw && typeof raw === 'object') {
|
|
const obj = raw as Record<string, unknown>;
|
|
const extra = obj['extra'];
|
|
const flag = (extra && typeof extra === 'object'
|
|
? (extra as Record<string, unknown>)['is_first_turn']
|
|
: undefined) ?? obj['is_first_turn'];
|
|
if (flag === false) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
export async function runSessionStart(opts: Partial<HookRunOptions> = {}): Promise<void> {
|
|
// Read stdin ONCE, then honor Hermes's is_first_turn inject gating without
|
|
// changing the shared handler body. On a non-first turn we exit 0 with no
|
|
// output (so the host pipe drains and the session is never blocked); the
|
|
// per-turn save is owned by the separate user-prompt-submit hook.
|
|
const exit = opts.exit ?? ((c: number): void => { process.exit(c); });
|
|
let raw: string;
|
|
try {
|
|
const reader = opts.readStdin ?? readStdinAsString;
|
|
raw = await reader();
|
|
if (!isFirstTurn(safeJsonParse(raw))) {
|
|
exit(0);
|
|
return;
|
|
}
|
|
} catch {
|
|
// Fail-open: a throwing stdin read must never escape to the host
|
|
// (mirrors runHook's exit-0-always contract for the pre-gate path).
|
|
exit(0);
|
|
return;
|
|
}
|
|
return runHook(makeSessionStartHandler(hermesAdapter), {
|
|
name: 'session-start',
|
|
loggerPrefix: 'hermes-hooks',
|
|
...opts,
|
|
// Re-feed the already-read payload so runHook does not block on a
|
|
// drained stdin.
|
|
readStdin: async () => raw,
|
|
});
|
|
}
|
|
|
|
const isMain = (() => {
|
|
try {
|
|
if (typeof process.argv[1] !== 'string') return false;
|
|
const url = new URL(`file://${process.argv[1].replace(/\\/g, '/')}`);
|
|
return url.href === import.meta.url;
|
|
} catch {
|
|
return false;
|
|
}
|
|
})();
|
|
if (isMain) {
|
|
void runSessionStart();
|
|
}
|