loudmouth-ai 0.1.0

package/dist/hooks/bundled/session-memory/handler.js

@@ -0,0 +1,140 @@
+/**
+ * Session memory hook handler
+ *
+ * Saves session context to memory when /new command is triggered
+ * Creates a new dated memory file with LLM-generated slug
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { resolveAgentWorkspaceDir } from "../../../agents/agent-scope.js";
+import { resolveAgentIdFromSessionKey } from "../../../routing/session-key.js";
+/**
+ * Read recent messages from session file for slug generation
+ */
+async function getRecentSessionContent(sessionFilePath) {
+    try {
+        const content = await fs.readFile(sessionFilePath, "utf-8");
+        const lines = content.trim().split("\n");
+        // Get last 15 lines (recent conversation)
+        const recentLines = lines.slice(-15);
+        // Parse JSONL and extract messages
+        const messages = [];
+        for (const line of recentLines) {
+            try {
+                const entry = JSON.parse(line);
+                // Session files have entries with type="message" containing a nested message object
+                if (entry.type === "message" && entry.message) {
+                    const msg = entry.message;
+                    const role = msg.role;
+                    if ((role === "user" || role === "assistant") && msg.content) {
+                        // Extract text content
+                        const text = Array.isArray(msg.content)
+                            ? msg.content.find((c) => c.type === "text")?.text
+                            : msg.content;
+                        if (text && !text.startsWith("/")) {
+                            messages.push(`${role}: ${text}`);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip invalid JSON lines
+            }
+        }
+        return messages.join("\n");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save session context to memory when /new command is triggered
+ */
+const saveSessionToMemory = async (event) => {
+    // Only trigger on 'new' command
+    if (event.type !== "command" || event.action !== "new") {
+        return;
+    }
+    try {
+        console.log("[session-memory] Hook triggered for /new command");
+        const context = event.context || {};
+        const cfg = context.cfg;
+        const agentId = resolveAgentIdFromSessionKey(event.sessionKey);
+        const workspaceDir = cfg
+            ? resolveAgentWorkspaceDir(cfg, agentId)
+            : path.join(os.homedir(), "clawd");
+        const memoryDir = path.join(workspaceDir, "memory");
+        await fs.mkdir(memoryDir, { recursive: true });
+        // Get today's date for filename
+        const now = new Date(event.timestamp);
+        const dateStr = now.toISOString().split("T")[0]; // YYYY-MM-DD
+        // Generate descriptive slug from session using LLM
+        const sessionEntry = (context.previousSessionEntry || context.sessionEntry || {});
+        const currentSessionId = sessionEntry.sessionId;
+        const currentSessionFile = sessionEntry.sessionFile;
+        console.log("[session-memory] Current sessionId:", currentSessionId);
+        console.log("[session-memory] Current sessionFile:", currentSessionFile);
+        console.log("[session-memory] cfg present:", !!cfg);
+        const sessionFile = currentSessionFile || undefined;
+        let slug = null;
+        let sessionContent = null;
+        if (sessionFile) {
+            // Get recent conversation content
+            sessionContent = await getRecentSessionContent(sessionFile);
+            console.log("[session-memory] sessionContent length:", sessionContent?.length || 0);
+            if (sessionContent && cfg) {
+                console.log("[session-memory] Calling generateSlugViaLLM...");
+                // Dynamically import the LLM slug generator (avoids module caching issues)
+                // When compiled, handler is at dist/hooks/bundled/session-memory/handler.js
+                // Going up ../.. puts us at dist/hooks/, so just add llm-slug-generator.js
+                const clawdbotRoot = path.resolve(path.dirname(import.meta.url.replace("file://", "")), "../..");
+                const slugGenPath = path.join(clawdbotRoot, "llm-slug-generator.js");
+                const { generateSlugViaLLM } = await import(slugGenPath);
+                // Use LLM to generate a descriptive slug
+                slug = await generateSlugViaLLM({ sessionContent, cfg });
+                console.log("[session-memory] Generated slug:", slug);
+            }
+        }
+        // If no slug, use timestamp
+        if (!slug) {
+            const timeSlug = now.toISOString().split("T")[1].split(".")[0].replace(/:/g, "");
+            slug = timeSlug.slice(0, 4); // HHMM
+            console.log("[session-memory] Using fallback timestamp slug:", slug);
+        }
+        // Create filename with date and slug
+        const filename = `${dateStr}-${slug}.md`;
+        const memoryFilePath = path.join(memoryDir, filename);
+        console.log("[session-memory] Generated filename:", filename);
+        console.log("[session-memory] Full path:", memoryFilePath);
+        // Format time as HH:MM:SS UTC
+        const timeStr = now.toISOString().split("T")[1].split(".")[0];
+        // Extract context details
+        const sessionId = sessionEntry.sessionId || "unknown";
+        const source = context.commandSource || "unknown";
+        // Build Markdown entry
+        const entryParts = [
+            `# Session: ${dateStr} ${timeStr} UTC`,
+            "",
+            `- **Session Key**: ${event.sessionKey}`,
+            `- **Session ID**: ${sessionId}`,
+            `- **Source**: ${source}`,
+            "",
+        ];
+        // Include conversation content if available
+        if (sessionContent) {
+            entryParts.push("## Conversation Summary", "", sessionContent, "");
+        }
+        const entry = entryParts.join("\n");
+        // Write to new memory file
+        await fs.writeFile(memoryFilePath, entry, "utf-8");
+        console.log("[session-memory] Memory file written successfully");
+        // Log completion (but don't send user-visible confirmation - it's internal housekeeping)
+        const relPath = memoryFilePath.replace(os.homedir(), "~");
+        console.log(`[session-memory] Session context saved to ${relPath}`);
+    }
+    catch (err) {
+        console.error("[session-memory] Failed to save session memory:", err instanceof Error ? err.message : String(err));
+    }
+};
+export default saveSessionToMemory;

package/dist/hooks/bundled/soul-evil/HOOK.md

@@ -0,0 +1,71 @@
+---
+name: soul-evil
+description: "Swap SOUL.md with SOUL_EVIL.md during a purge window or by random chance"
+homepage: https://docs.clawd.bot/hooks/soul-evil
+metadata:
+  {
+    "clawdbot":
+      {
+        "emoji": "😈",
+        "events": ["agent:bootstrap"],
+        "requires": { "config": ["hooks.internal.entries.soul-evil.enabled"] },
+        "install": [{ "id": "bundled", "kind": "bundled", "label": "Bundled with Clawdbot" }],
+      },
+  }
+---
+
+# SOUL Evil Hook
+
+Replaces the injected `SOUL.md` content with `SOUL_EVIL.md` during a daily purge window or by random chance.
+
+## What It Does
+
+When enabled and the trigger conditions match, the hook swaps the **injected** `SOUL.md` content before the system prompt is built. It does **not** modify files on disk.
+
+## Files
+
+- `SOUL.md` — normal persona (always read)
+- `SOUL_EVIL.md` — alternate persona (read only when triggered)
+
+You can change the filename via hook config.
+
+## Configuration
+
+Add this to your config (`~/.clawdbot/clawdbot.json`):
+
+```json
+{
+  "hooks": {
+    "internal": {
+      "enabled": true,
+      "entries": {
+        "soul-evil": {
+          "enabled": true,
+          "file": "SOUL_EVIL.md",
+          "chance": 0.1,
+          "purge": { "at": "21:00", "duration": "15m" }
+        }
+      }
+    }
+  }
+}
+```
+
+### Options
+
+- `file` (string): alternate SOUL filename (default: `SOUL_EVIL.md`)
+- `chance` (number 0–1): random chance per run to swap in SOUL_EVIL
+- `purge.at` (HH:mm): daily purge window start time (24h)
+- `purge.duration` (duration): window length (e.g. `30s`, `10m`, `1h`)
+
+**Precedence:** purge window wins over chance.
+
+## Requirements
+
+- `hooks.internal.entries.soul-evil.enabled` must be set to `true`
+
+## Enable
+
+```bash
+clawdbot hooks enable soul-evil
+```

package/dist/hooks/bundled/soul-evil/handler.js

@@ -0,0 +1,36 @@
+import { isSubagentSessionKey } from "../../../routing/session-key.js";
+import { resolveHookConfig } from "../../config.js";
+import { isAgentBootstrapEvent } from "../../hooks.js";
+import { applySoulEvilOverride, resolveSoulEvilConfigFromHook } from "../../soul-evil.js";
+const HOOK_KEY = "soul-evil";
+const soulEvilHook = async (event) => {
+    if (!isAgentBootstrapEvent(event))
+        return;
+    const context = event.context;
+    if (context.sessionKey && isSubagentSessionKey(context.sessionKey))
+        return;
+    const cfg = context.cfg;
+    const hookConfig = resolveHookConfig(cfg, HOOK_KEY);
+    if (!hookConfig || hookConfig.enabled === false)
+        return;
+    const soulConfig = resolveSoulEvilConfigFromHook(hookConfig, {
+        warn: (message) => console.warn(`[soul-evil] ${message}`),
+    });
+    if (!soulConfig)
+        return;
+    const workspaceDir = context.workspaceDir;
+    if (!workspaceDir || !Array.isArray(context.bootstrapFiles))
+        return;
+    const updated = await applySoulEvilOverride({
+        files: context.bootstrapFiles,
+        workspaceDir,
+        config: soulConfig,
+        userTimezone: cfg?.agents?.defaults?.userTimezone,
+        log: {
+            warn: (message) => console.warn(`[soul-evil] ${message}`),
+            debug: (message) => console.debug?.(`[soul-evil] ${message}`),
+        },
+    });
+    context.bootstrapFiles = updated;
+};
+export default soulEvilHook;

package/dist/hooks/bundled-dir.js

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function resolveBundledHooksDir() {
+    const override = process.env.CLAWDBOT_BUNDLED_HOOKS_DIR?.trim();
+    if (override)
+        return override;
+    // bun --compile: ship a sibling `hooks/bundled/` next to the executable.
+    try {
+        const execDir = path.dirname(process.execPath);
+        const sibling = path.join(execDir, "hooks", "bundled");
+        if (fs.existsSync(sibling))
+            return sibling;
+    }
+    catch {
+        // ignore
+    }
+    // npm: resolve `<packageRoot>/dist/hooks/bundled` relative to this module (compiled hooks).
+    // This path works when installed via npm: node_modules/clawdbot/dist/hooks/bundled-dir.js
+    try {
+        const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+        const distBundled = path.join(moduleDir, "bundled");
+        if (fs.existsSync(distBundled))
+            return distBundled;
+    }
+    catch {
+        // ignore
+    }
+    // dev: resolve `<packageRoot>/src/hooks/bundled` relative to dist/hooks/bundled-dir.js
+    // This path works in dev: dist/hooks/bundled-dir.js -> ../../src/hooks/bundled
+    try {
+        const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+        const root = path.resolve(moduleDir, "..", "..");
+        const srcBundled = path.join(root, "src", "hooks", "bundled");
+        if (fs.existsSync(srcBundled))
+            return srcBundled;
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}

package/dist/hooks/config.js

@@ -0,0 +1,122 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveHookKey } from "./frontmatter.js";
+const DEFAULT_CONFIG_VALUES = {
+    "browser.enabled": true,
+    "workspace.dir": true,
+};
+function isTruthy(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return value !== 0;
+    if (typeof value === "string")
+        return value.trim().length > 0;
+    return true;
+}
+export function resolveConfigPath(config, pathStr) {
+    const parts = pathStr.split(".").filter(Boolean);
+    let current = config;
+    for (const part of parts) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+export function isConfigPathTruthy(config, pathStr) {
+    const value = resolveConfigPath(config, pathStr);
+    if (value === undefined && pathStr in DEFAULT_CONFIG_VALUES) {
+        return DEFAULT_CONFIG_VALUES[pathStr] === true;
+    }
+    return isTruthy(value);
+}
+export function resolveHookConfig(config, hookKey) {
+    const hooks = config?.hooks?.internal?.entries;
+    if (!hooks || typeof hooks !== "object")
+        return undefined;
+    const entry = hooks[hookKey];
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    return entry;
+}
+export function resolveRuntimePlatform() {
+    return process.platform;
+}
+export function hasBinary(bin) {
+    const pathEnv = process.env.PATH ?? "";
+    const parts = pathEnv.split(path.delimiter).filter(Boolean);
+    for (const part of parts) {
+        const candidate = path.join(part, bin);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            // keep scanning
+        }
+    }
+    return false;
+}
+export function shouldIncludeHook(params) {
+    const { entry, config, eligibility } = params;
+    const hookKey = resolveHookKey(entry.hook.name, entry);
+    const hookConfig = resolveHookConfig(config, hookKey);
+    const pluginManaged = entry.hook.source === "clawdbot-plugin";
+    const osList = entry.clawdbot?.os ?? [];
+    const remotePlatforms = eligibility?.remote?.platforms ?? [];
+    // Check if explicitly disabled
+    if (!pluginManaged && hookConfig?.enabled === false)
+        return false;
+    // Check OS requirement
+    if (osList.length > 0 &&
+        !osList.includes(resolveRuntimePlatform()) &&
+        !remotePlatforms.some((platform) => osList.includes(platform))) {
+        return false;
+    }
+    // If marked as 'always', bypass all other checks
+    if (entry.clawdbot?.always === true) {
+        return true;
+    }
+    // Check required binaries (all must be present)
+    const requiredBins = entry.clawdbot?.requires?.bins ?? [];
+    if (requiredBins.length > 0) {
+        for (const bin of requiredBins) {
+            if (hasBinary(bin))
+                continue;
+            if (eligibility?.remote?.hasBin?.(bin))
+                continue;
+            return false;
+        }
+    }
+    // Check anyBins (at least one must be present)
+    const requiredAnyBins = entry.clawdbot?.requires?.anyBins ?? [];
+    if (requiredAnyBins.length > 0) {
+        const anyFound = requiredAnyBins.some((bin) => hasBinary(bin)) ||
+            eligibility?.remote?.hasAnyBin?.(requiredAnyBins);
+        if (!anyFound)
+            return false;
+    }
+    // Check required environment variables
+    const requiredEnv = entry.clawdbot?.requires?.env ?? [];
+    if (requiredEnv.length > 0) {
+        for (const envName of requiredEnv) {
+            if (process.env[envName])
+                continue;
+            if (hookConfig?.env?.[envName])
+                continue;
+            return false;
+        }
+    }
+    // Check required config paths
+    const requiredConfig = entry.clawdbot?.requires?.config ?? [];
+    if (requiredConfig.length > 0) {
+        for (const configPath of requiredConfig) {
+            if (!isConfigPathTruthy(config, configPath))
+                return false;
+        }
+    }
+    return true;
+}

package/dist/hooks/frontmatter.js

@@ -0,0 +1,105 @@
+import JSON5 from "json5";
+import { parseFrontmatterBlock } from "../markdown/frontmatter.js";
+import { parseBooleanValue } from "../utils/boolean.js";
+export function parseFrontmatter(content) {
+    return parseFrontmatterBlock(content);
+}
+function normalizeStringList(input) {
+    if (!input)
+        return [];
+    if (Array.isArray(input)) {
+        return input.map((value) => String(value).trim()).filter(Boolean);
+    }
+    if (typeof input === "string") {
+        return input
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+function parseInstallSpec(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const raw = input;
+    const kindRaw = typeof raw.kind === "string" ? raw.kind : typeof raw.type === "string" ? raw.type : "";
+    const kind = kindRaw.trim().toLowerCase();
+    if (kind !== "bundled" && kind !== "npm" && kind !== "git") {
+        return undefined;
+    }
+    const spec = {
+        kind: kind,
+    };
+    if (typeof raw.id === "string")
+        spec.id = raw.id;
+    if (typeof raw.label === "string")
+        spec.label = raw.label;
+    const bins = normalizeStringList(raw.bins);
+    if (bins.length > 0)
+        spec.bins = bins;
+    if (typeof raw.package === "string")
+        spec.package = raw.package;
+    if (typeof raw.repository === "string")
+        spec.repository = raw.repository;
+    return spec;
+}
+function getFrontmatterValue(frontmatter, key) {
+    const raw = frontmatter[key];
+    return typeof raw === "string" ? raw : undefined;
+}
+function parseFrontmatterBool(value, fallback) {
+    const parsed = parseBooleanValue(value);
+    return parsed === undefined ? fallback : parsed;
+}
+export function resolveClawdbotMetadata(frontmatter) {
+    const raw = getFrontmatterValue(frontmatter, "metadata");
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON5.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        const clawdbot = parsed.clawdbot;
+        if (!clawdbot || typeof clawdbot !== "object")
+            return undefined;
+        const clawdbotObj = clawdbot;
+        const requiresRaw = typeof clawdbotObj.requires === "object" && clawdbotObj.requires !== null
+            ? clawdbotObj.requires
+            : undefined;
+        const installRaw = Array.isArray(clawdbotObj.install) ? clawdbotObj.install : [];
+        const install = installRaw
+            .map((entry) => parseInstallSpec(entry))
+            .filter((entry) => Boolean(entry));
+        const osRaw = normalizeStringList(clawdbotObj.os);
+        const eventsRaw = normalizeStringList(clawdbotObj.events);
+        return {
+            always: typeof clawdbotObj.always === "boolean" ? clawdbotObj.always : undefined,
+            emoji: typeof clawdbotObj.emoji === "string" ? clawdbotObj.emoji : undefined,
+            homepage: typeof clawdbotObj.homepage === "string" ? clawdbotObj.homepage : undefined,
+            hookKey: typeof clawdbotObj.hookKey === "string" ? clawdbotObj.hookKey : undefined,
+            export: typeof clawdbotObj.export === "string" ? clawdbotObj.export : undefined,
+            os: osRaw.length > 0 ? osRaw : undefined,
+            events: eventsRaw.length > 0 ? eventsRaw : [],
+            requires: requiresRaw
+                ? {
+                    bins: normalizeStringList(requiresRaw.bins),
+                    anyBins: normalizeStringList(requiresRaw.anyBins),
+                    env: normalizeStringList(requiresRaw.env),
+                    config: normalizeStringList(requiresRaw.config),
+                }
+                : undefined,
+            install: install.length > 0 ? install : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveHookInvocationPolicy(frontmatter) {
+    return {
+        enabled: parseFrontmatterBool(getFrontmatterValue(frontmatter, "enabled"), true),
+    };
+}
+export function resolveHookKey(hookName, entry) {
+    return entry?.clawdbot?.hookKey ?? hookName;
+}