@shuyhere/takotako 0.0.1

package/dist/hooks/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../src/hooks/hooks.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,OAAO,cAAc;IACjB,QAAQ,GAAG,IAAI,GAAG,EAA4B,CAAC;IAEvD,gDAAgD;IAChD,EAAE,CAAC,KAAgB,EAAE,OAAoB;QACvC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC/B,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED,8CAA8C;IAC9C,GAAG,CAAC,KAAgB,EAAE,OAAoB;QACxC,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,GAAG,KAAK,CAAC,CAAC;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACtC,CAAC;IAED,6EAA6E;IAC7E,KAAK,CAAC,IAAI,CAAC,KAAgB,EAAE,GAAgB;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,KAAK,MAAM,OAAO,IAAI,IAAI,EAAE,CAAC;YAC3B,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IAED,6DAA6D;IAC7D,KAAK,CAAC,KAAiB;QACrB,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACxB,CAAC;IACH,CAAC;IAED,yDAAyD;IACzD,aAAa,CAAC,KAAgB;QAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC;IAC/C,CAAC;CACF"}

package/dist/hooks/types.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Hook system types — lifecycle events for the Tako kernel.
+ *
+ * Hooks let skill arms and extensions intercept key moments in
+ * the agent lifecycle without modifying core code. They follow
+ * a simple event emitter pattern with ordered handler execution.
+ *
+ * Design rules:
+ * - Hooks fire in registration order (no priority system)
+ * - Handlers can modify the context's mutable `data` bag
+ * - Handlers can be async but should not block indefinitely
+ * - Hooks can inspect but NOT block tool calls (use tool policy for that)
+ * - Skill arms register hooks when loaded via the HookSystem
+ *
+ * @example
+ * ```typescript
+ * hooks.on('before_tool_call', async (ctx) => {
+ *   console.log(`Tool: ${ctx.data.toolName}`);
+ * });
+ * ```
+ */
+/**
+ * Lifecycle events that hooks can listen to.
+ *
+ * Agent lifecycle:
+ * - `before_prompt_build` — inject context before system prompt assembly
+ * - `agent_start` — agent loop is starting a new turn
+ * - `agent_end` — agent loop completed (includes turn count)
+ *
+ * Tool lifecycle:
+ * - `before_tool_call` — intercept tool params before execution
+ * - `after_tool_call` — inspect/transform tool results after execution
+ *
+ * Session lifecycle:
+ * - `session_start` — new session created for a user
+ * - `session_end` — session closed or expired
+ *
+ * Message lifecycle:
+ * - `message_received` — inbound message from any channel
+ * - `message_sending` — outbound message about to be sent
+ *
+ * Gateway lifecycle:
+ * - `gateway_start` — WebSocket gateway daemon started
+ * - `gateway_stop` — gateway shutting down
+ *
+ * Channel lifecycle (skill-loaded channels):
+ * - `channel_register` — a skill channel was registered
+ * - `channel_unregister` — a skill channel was unregistered
+ *
+ * Compaction lifecycle:
+ * - `before_compaction` — about to compact — last chance to save state
+ * - `after_compaction` — compaction complete — session init context injected
+ *
+ * Sandbox lifecycle:
+ * - `sandbox_container_created` — sandbox container created and started
+ * - `sandbox_container_destroyed` — sandbox container stopped and removed
+ * - `sandbox_exec_blocked` — a command was blocked by exec safety
+ */
+export type HookEvent = 'before_prompt_build' | 'agent_start' | 'agent_end' | 'before_tool_call' | 'after_tool_call' | 'session_start' | 'session_end' | 'message_received' | 'message_sending' | 'gateway_start' | 'gateway_stop' | 'channel_register' | 'channel_unregister' | 'before_compaction' | 'after_compaction' | 'sandbox_container_created' | 'sandbox_container_destroyed' | 'sandbox_exec_blocked';
+/**
+ * Context passed to every hook handler.
+ * The `data` bag is mutable — hooks can read and modify it to pass
+ * information between handlers and back to the emitting code.
+ */
+export interface HookContext {
+    /** The event that triggered this hook */
+    event: HookEvent;
+    /** Current session ID (if applicable) */
+    sessionId?: string;
+    /** Mutable data bag — hooks can read, modify, and add entries */
+    data: Record<string, unknown>;
+    /** Unix timestamp of the hook invocation */
+    timestamp: number;
+}
+/** A hook handler function. Can be sync or async. */
+export type HookHandler = (ctx: HookContext) => void | Promise<void>;
+/**
+ * HookSystem — the lifecycle event trait.
+ *
+ * A simple event emitter for intercepting key moments in the agent
+ * lifecycle. Skill arms and extensions register handlers to observe
+ * or modify behavior without touching core code.
+ *
+ * Built-in implementation:
+ * - {@link TakoHookSystem} — simple ordered event emitter
+ */
+export interface HookSystem {
+    /**
+     * Register a handler for a lifecycle event.
+     * Handlers fire in registration order.
+     *
+     * @param event - The lifecycle event to listen for
+     * @param handler - Callback invoked when the event fires
+     */
+    on(event: HookEvent, handler: HookHandler): void;
+    /**
+     * Remove a previously registered handler.
+     *
+     * @param event - The lifecycle event
+     * @param handler - The exact handler reference to remove
+     */
+    off(event: HookEvent, handler: HookHandler): void;
+    /**
+     * Emit an event, invoking all registered handlers in order.
+     * Each handler is awaited before the next fires.
+     *
+     * @param event - The lifecycle event to emit
+     * @param ctx - Context passed to all handlers
+     */
+    emit(event: HookEvent, ctx: HookContext): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/hooks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/hooks/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,MAAM,SAAS,GAEjB,qBAAqB,GACrB,aAAa,GACb,WAAW,GAEX,kBAAkB,GAClB,iBAAiB,GAEjB,eAAe,GACf,aAAa,GAEb,kBAAkB,GAClB,iBAAiB,GAEjB,eAAe,GACf,cAAc,GAEd,kBAAkB,GAClB,oBAAoB,GAEpB,mBAAmB,GACnB,kBAAkB,GAElB,2BAA2B,GAC3B,6BAA6B,GAC7B,sBAAsB,CAAC;AAI3B;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,yCAAyC;IACzC,KAAK,EAAE,SAAS,CAAC;IACjB,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qDAAqD;AACrD,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAIrE;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;OAMG;IACH,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAEjD;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAElD;;;;;;OAMG;IACH,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzD"}

package/dist/hooks/types.js

@@ -0,0 +1,23 @@
+/**
+ * Hook system types — lifecycle events for the Tako kernel.
+ *
+ * Hooks let skill arms and extensions intercept key moments in
+ * the agent lifecycle without modifying core code. They follow
+ * a simple event emitter pattern with ordered handler execution.
+ *
+ * Design rules:
+ * - Hooks fire in registration order (no priority system)
+ * - Handlers can modify the context's mutable `data` bag
+ * - Handlers can be async but should not block indefinitely
+ * - Hooks can inspect but NOT block tool calls (use tool policy for that)
+ * - Skill arms register hooks when loaded via the HookSystem
+ *
+ * @example
+ * ```typescript
+ * hooks.on('before_tool_call', async (ctx) => {
+ *   console.log(`Tool: ${ctx.data.toolName}`);
+ * });
+ * ```
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/hooks/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/hooks/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env bun
+/**
+ * Tako 🐙 — Agent-as-CPU OS: minimal core + pluggable skill arms.
+ *
+ * CLI entry point with subcommands:
+ *   tako              Start interactive agent (alias for `tako start`)
+ *   tako start        Start the agent in foreground (default)
+ *   tako start -d     Start as background daemon
+ *   tako stop         Stop the daemon
+ *   tako restart      Restart the daemon
+ *   tako status       Show daemon & runtime status
+ *   tako tui          Attach TUI to running daemon
+ *   tako dev          Development mode (watch + auto-restart)
+ *   tako onboard      Interactive first-time setup wizard
+ *   tako doctor       Run health checks
+ *   tako models       Model management (list, set, auth, status)
+ *   tako channels     Channel management (list, add, remove, status)
+ *   tako skills list  List discovered skills
+ *   tako skills install <name>  Install a skill from the ecosystem
+ *   tako skills info <name>     Show skill details
+ *   tako agents       Agent management (list, add, remove, info)
+ *   tako sessions     Session management (list, history)
+ *   tako version      Print version
+ *   tako help         Show help
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;GAuBG"}