@dnai/dynamicllm 0.1.1 → 0.2.1

package/dist/{setup.js → cli/init.js}

@@ -1,9 +1,9 @@
 import { createInterface } from "node:readline/promises";
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { stdin, stdout } from "node:process";
-const DEFAULT_NETWORK_DIR = join(homedir(), ".dynamicllm", "network");
+import { bootstrap } from "../core/bootstrap.js";
 const CONFIG_PATH = join(homedir(), ".dynamicllm", "config.json");
 const AGENTS = [
     { name: "Claude Code", key: "claude" },
@@ -12,44 +12,36 @@ const AGENTS = [
     { name: "Codex", key: "codex" },
     { name: "Other (show config)", key: "other" },
 ];
-function loadConfig() {
-    if (!existsSync(CONFIG_PATH))
-        return null;
-    try {
-        return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
 function saveConfig(config) {
     const dir = join(homedir(), ".dynamicllm");
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
 }
+function getMcpServerConfig(networkDir) {
+    return {
+        command: "dynamicllm",
+        args: ["mcp"],
+        env: {
+            DYNAMICLLM_NETWORK_DIR: networkDir,
+        },
+    };
+}
 function getMcpJson(networkDir) {
     return {
         mcpServers: {
-            dynamicllm: {
-                command: "dynamicllm",
-                env: {
-                    DYNAMICLLM_NETWORK_DIR: networkDir,
-                },
-            },
+            dynamicllm: getMcpServerConfig(networkDir),
         },
     };
 }
 function writeMcpJsonFile(dir, networkDir) {
     const mcpPath = join(dir, "mcp.json");
     const mcpConfig = getMcpJson(networkDir);
-    // If file exists, merge rather than overwrite
     if (existsSync(mcpPath)) {
         try {
             const existing = JSON.parse(readFileSync(mcpPath, "utf-8"));
             existing.mcpServers = existing.mcpServers ?? {};
-            existing.mcpServers.dynamicllm =
-                mcpConfig["mcpServers"];
+            existing.mcpServers.dynamicllm = getMcpServerConfig(networkDir);
             writeFileSync(mcpPath, JSON.stringify(existing, null, 2), "utf-8");
             return true;
         }
@@ -57,7 +49,6 @@ function writeMcpJsonFile(dir, networkDir) {
             return false;
         }
     }
-    // Create directory and file
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
@@ -68,13 +59,13 @@ async function registerAgent(agent, networkDir, rl) {
         case "claude": {
             const { execSync } = await import("node:child_process");
             try {
-                execSync(`claude mcp add --scope user dynamicllm -e DYNAMICLLM_NETWORK_DIR="${networkDir}" -- dynamicllm`, { stdio: "inherit" });
+                execSync(`claude mcp add --scope user dynamicllm -e DYNAMICLLM_NETWORK_DIR="${networkDir}" -- dynamicllm mcp`, { stdio: "inherit" });
                 console.log("  Registered with Claude Code (user-level).");
             }
             catch {
                 console.log("  Could not auto-register with Claude Code.");
                 console.log("  Run manually:");
-                console.log(`    claude mcp add --scope user dynamicllm -e DYNAMICLLM_NETWORK_DIR="${networkDir}" -- dynamicllm`);
+                console.log(`    claude mcp add --scope user dynamicllm -e DYNAMICLLM_NETWORK_DIR="${networkDir}" -- dynamicllm mcp`);
             }
             break;
         }
@@ -120,33 +111,23 @@ async function registerAgent(agent, networkDir, rl) {
         }
     }
 }
-export async function setup() {
+export async function init() {
     const rl = createInterface({ input: stdin, output: stdout });
-    const existing = loadConfig();
+    const { networkDir: defaultDir } = bootstrap();
     console.log("");
-    console.log("  DynamicLLM Setup");
-    console.log("  ───────────────");
+    console.log("  DynamicLLM Init");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     console.log("");
-    // Ensure global install so `dynamicllm` command is available
-    const { execSync } = await import("node:child_process");
-    try {
-        execSync("which dynamicllm", { stdio: "ignore" });
-    }
-    catch {
-        console.log("  Installing DynamicLLM globally...");
-        try {
-            execSync("npm install -g @dnai/dynamicllm", { stdio: "inherit" });
-            console.log("");
-        }
-        catch {
-            console.log("  Warning: Could not install globally. Run: npm install -g @dnai/dynamicllm");
-            console.log("");
-        }
-    }
     // 1. Network directory
-    const defaultDir = existing?.networkDir ?? DEFAULT_NETWORK_DIR;
-    const dirAnswer = await rl.question(`  Network directory [${defaultDir}]: `);
-    const networkDir = dirAnswer.trim().replace(/^['"]|['"]$/g, "") || defaultDir;
+    console.log(`  Your network nodes will be stored in:`);
+    console.log(`  ${defaultDir}`);
+    console.log("");
+    const changeDir = await rl.question("  Change location? [y/N]: ");
+    let networkDir = defaultDir;
+    if (changeDir.trim().toLowerCase() === "y") {
+        const dirAnswer = await rl.question(`  New directory: `);
+        networkDir = dirAnswer.trim().replace(/^['"]|['"]$/g, "") || defaultDir;
+    }
     if (!existsSync(networkDir)) {
         const create = await rl.question(`  Directory doesn't exist. Create it? [Y/n]: `);
         if (create.trim().toLowerCase() !== "n") {
@@ -174,7 +155,7 @@ export async function setup() {
     console.log("");
     await registerAgent(selectedAgent.key, networkDir, rl);
     console.log("");
-    console.log("  Setup complete. Start using DynamicLLM with your AI agent.");
+    console.log("  Init complete. Start using DynamicLLM with your AI agent.");
     console.log("");
     rl.close();
 }

package/dist/core/bootstrap.d.ts

@@ -0,0 +1,14 @@
+export interface BootstrapResult {
+    networkDir: string;
+    /** True when this invocation created the default config (first run). */
+    created: boolean;
+}
+/**
+ * Resolves the network directory, creating defaults on first use if needed.
+ *
+ * Precedence:
+ * 1. DYNAMICLLM_NETWORK_DIR env var — used as-is, no config written
+ * 2. ~/.dynamicllm/config.json — existing valid config
+ * 3. Create defaults — ~/.dynamicllm/, ~/.dynamicllm/network/, config.json
+ */
+export declare function bootstrap(): BootstrapResult;

package/dist/core/bootstrap.js

@@ -0,0 +1,38 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CONFIG_DIR = join(homedir(), ".dynamicllm");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+const DEFAULT_NETWORK_DIR = join(CONFIG_DIR, "network");
+/**
+ * Resolves the network directory, creating defaults on first use if needed.
+ *
+ * Precedence:
+ * 1. DYNAMICLLM_NETWORK_DIR env var — used as-is, no config written
+ * 2. ~/.dynamicllm/config.json — existing valid config
+ * 3. Create defaults — ~/.dynamicllm/, ~/.dynamicllm/network/, config.json
+ */
+export function bootstrap() {
+    // 1. Env var takes absolute precedence
+    if (process.env.DYNAMICLLM_NETWORK_DIR) {
+        return { networkDir: process.env.DYNAMICLLM_NETWORK_DIR, created: false };
+    }
+    // 2. Existing valid config
+    if (existsSync(CONFIG_PATH)) {
+        try {
+            const config = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+            if (typeof config.networkDir === "string" && config.networkDir) {
+                return { networkDir: config.networkDir, created: false };
+            }
+        }
+        catch {
+            // Invalid JSON — fall through to create defaults
+        }
+    }
+    // 3. Create defaults
+    if (!existsSync(DEFAULT_NETWORK_DIR)) {
+        mkdirSync(DEFAULT_NETWORK_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_PATH, JSON.stringify({ networkDir: DEFAULT_NETWORK_DIR }, null, 2), "utf-8");
+    return { networkDir: DEFAULT_NETWORK_DIR, created: true };
+}

package/dist/core/constants.d.ts

@@ -0,0 +1,4 @@
+import type { QualityDefinition, AntidoteDefinition } from "./types.js";
+/** Web demo UI rendering constants — also exported for dna-web consumption */
+export declare const QUALITIES: QualityDefinition[];
+export declare const ANTIDOTES: AntidoteDefinition[];

package/dist/core/constants.js

@@ -0,0 +1,71 @@
+/** Web demo UI rendering constants — also exported for dna-web consumption */
+export const QUALITIES = [
+    {
+        id: "play",
+        name: "Play",
+        abbreviation: "PLY",
+        question: "Where do you want to add >Play today?",
+    },
+    {
+        id: "beauty",
+        name: "Beauty",
+        abbreviation: "BTY",
+        question: "Where do you want to add >Beauty today?",
+    },
+    {
+        id: "mystery",
+        name: "Mystery",
+        abbreviation: "MTY",
+        question: "Where do you want to add >Mystery today?",
+    },
+    {
+        id: "love",
+        name: "Love",
+        abbreviation: "LVE",
+        question: "Where do you want to add >Love today?",
+    },
+    {
+        id: "infinity",
+        name: "Infinity",
+        abbreviation: "INF",
+        question: "Where do you want to add >Infinity today?",
+    },
+    {
+        id: "story",
+        name: "Story",
+        abbreviation: "STY",
+        question: "Where do you want to add >Story today?",
+    },
+];
+export const ANTIDOTES = [
+    {
+        id: "agentism",
+        dynamicPole: "Liberated Agentism",
+        staticPole: "Directed Interventionism",
+    },
+    {
+        id: "optimism",
+        dynamicPole: "Constructive Optimism",
+        staticPole: "Constrictive Pessimism",
+    },
+    {
+        id: "fallibilism",
+        dynamicPole: "Objective Fallibilism",
+        staticPole: "Authoritative Justificationism",
+    },
+    {
+        id: "nodalism",
+        dynamicPole: "Polycentric Nodalism",
+        staticPole: "Monocentric Globalism",
+    },
+    {
+        id: "authenticism",
+        dynamicPole: "Vertical Authenticism",
+        staticPole: "Horizontal Mimeticism",
+    },
+    {
+        id: "creativism",
+        dynamicPole: "Oxidative Creativism",
+        staticPole: "Reductive Parochialism",
+    },
+];

package/dist/{lib → core}/fetcher.d.ts

@@ -1,22 +1,21 @@
 import type { NetworkIndex } from "./types.js";
+/** Slugs that are part of the bundled framework and cannot be overridden by user files */
+export declare const FRAMEWORK_SLUGS: Set<string>;
 export declare class NetworkFetcher {
-    private cdnUrl;
-    private cache;
     private networkDir;
+    private frameworkDir;
     private localContents;
+    private frameworkContents;
     private mergedIndex;
     constructor(opts?: {
-        cdnUrl?: string;
-        cacheDir?: string;
         networkDir?: string;
     });
     fetchIndex(): Promise<NetworkIndex>;
+    /** Load bundled framework files from the framework/ directory */
+    private loadFramework;
     /** Invalidate cached merged index (call after saving new files) */
     invalidateIndex(): void;
     fetchNode(slug: string): Promise<string>;
     fetchSource(slug: string): Promise<string>;
     fetchMeta(slug: string): Promise<string>;
-    private fetchCdnIndex;
-    private fetchFile;
-    private fetchRemote;
 }

package/dist/core/fetcher.js

@@ -0,0 +1,247 @@
+import { existsSync, readdirSync, readFileSync, statSync, } from "node:fs";
+import { join, basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+/** Resolve the bundled framework/ directory relative to this package */
+function resolveFrameworkDir() {
+    const thisFile = fileURLToPath(import.meta.url);
+    // dist/core/fetcher.js → up two levels to package root → framework/
+    return join(dirname(thisFile), "..", "..", "framework");
+}
+/** Recursively collect all .md files under a directory, returning absolute paths */
+function collectMarkdownFiles(dir) {
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...collectMarkdownFiles(fullPath));
+        }
+        else if (entry.name.endsWith(".md")) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+/** Slugs that are part of the bundled framework and cannot be overridden by user files */
+export const FRAMEWORK_SLUGS = new Set([
+    "system-prompt", "conventions",
+    "logos", "pathos", "mythos",
+    "play", "beauty", "story", "infinity", "mystery", "love",
+    "liberated-agentism", "constructive-optimism", "objective-fallibilism",
+    "polycentric-nodalism", "vertical-authenticism", "oxidative-creativism",
+]);
+/** Parse YAML frontmatter from a markdown string */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return {};
+    const fm = {};
+    for (const line of match[1].split("\n")) {
+        const colon = line.indexOf(":");
+        if (colon < 0)
+            continue;
+        const key = line.slice(0, colon).trim();
+        let val = line.slice(colon + 1).trim();
+        // Parse YAML arrays: [a, b, c]
+        if (typeof val === "string" && val.startsWith("[") && val.endsWith("]")) {
+            val = val
+                .slice(1, -1)
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+        fm[key] = val;
+    }
+    return fm;
+}
+/** Scan a local directory of .md files and build index entries.
+ *  If `protectFramework` is true, throws on slug collisions with framework slugs. */
+function scanLocalDir(dir, protectFramework) {
+    const nodes = [];
+    const sources = [];
+    const fileContents = new Map();
+    if (!existsSync(dir))
+        return { nodes, sources, fileContents };
+    const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+        const filePath = join(dir, file);
+        const content = readFileSync(filePath, "utf-8");
+        const slug = basename(file, ".md").toLowerCase().replace(/[_\s]+/g, "-");
+        // Protect framework slugs from user override
+        if (protectFramework && FRAMEWORK_SLUGS.has(slug)) {
+            throw new Error(`Slug collision: "${slug}" is a protected framework slug and cannot be overridden by user network files. ` +
+                `Remove or rename "${file}" in your network directory.`);
+        }
+        const fm = parseFrontmatter(content);
+        const size = statSync(filePath).size;
+        const hash = createHash("sha256").update(content).digest("hex").slice(0, 8);
+        const type = fm.type;
+        const name = fm.name ?? slug;
+        const tags = fm.tags ?? [];
+        const VALID_TYPES = new Set(["person", "idea", "antidote", "lens", "quality", "source", "synthesis"]);
+        if (type && !VALID_TYPES.has(type)) {
+            console.warn(`[dynamicllm] Skipping ${file}: invalid type "${type}"`);
+            continue;
+        }
+        if (type === "source") {
+            sources.push({
+                slug,
+                displayName: name,
+                type: "source",
+                author: fm.author ?? "",
+                tags,
+                hash,
+                size,
+            });
+            fileContents.set(`sources/${slug}.md`, content);
+        }
+        else if (type) {
+            const entry = {
+                slug,
+                displayName: name,
+                type: type,
+                tags,
+                hash,
+                size,
+            };
+            if (type === "antidote" && fm.mind_virus) {
+                entry.mindVirus = fm.mind_virus;
+            }
+            if (fm.derived_from) {
+                entry.derivedFrom = fm.derived_from;
+            }
+            nodes.push(entry);
+            fileContents.set(`nodes/${slug}.md`, content);
+        }
+    }
+    return { nodes, sources, fileContents };
+}
+export class NetworkFetcher {
+    networkDir;
+    frameworkDir;
+    localContents = new Map();
+    frameworkContents = new Map();
+    mergedIndex = null;
+    constructor(opts) {
+        this.networkDir = opts?.networkDir ?? null;
+        this.frameworkDir = resolveFrameworkDir();
+    }
+    async fetchIndex() {
+        if (this.mergedIndex)
+            return this.mergedIndex;
+        // 1. Load bundled framework files
+        const framework = this.loadFramework();
+        // 2. Scan local user network directory (with framework slug protection)
+        if (this.networkDir) {
+            const local = scanLocalDir(this.networkDir, true);
+            this.localContents = local.fileContents;
+            // Merge: framework + local user content
+            this.mergedIndex = {
+                schemaVersion: 1,
+                networkVersion: new Date().toISOString().slice(0, 10),
+                nodes: [...framework.nodes, ...local.nodes],
+                sources: [...framework.sources, ...local.sources],
+                meta: framework.meta,
+            };
+        }
+        else {
+            this.mergedIndex = {
+                schemaVersion: 1,
+                networkVersion: new Date().toISOString().slice(0, 10),
+                nodes: framework.nodes,
+                sources: framework.sources,
+                meta: framework.meta,
+            };
+        }
+        return this.mergedIndex;
+    }
+    /** Load bundled framework files from the framework/ directory */
+    loadFramework() {
+        const nodes = [];
+        const sources = [];
+        const meta = [];
+        if (!existsSync(this.frameworkDir)) {
+            console.warn(`[dynamicllm] Framework directory not found: ${this.frameworkDir}`);
+            return { nodes, sources, meta };
+        }
+        const files = collectMarkdownFiles(this.frameworkDir);
+        for (const filePath of files) {
+            const content = readFileSync(filePath, "utf-8");
+            const slug = basename(filePath, ".md").toLowerCase().replace(/[_\s]+/g, "-");
+            const fm = parseFrontmatter(content);
+            const size = statSync(filePath).size;
+            const hash = createHash("sha256").update(content).digest("hex").slice(0, 8);
+            if (fm.kind === "meta") {
+                meta.push({
+                    slug,
+                    displayName: fm.name ?? slug,
+                    kind: "meta",
+                });
+                this.frameworkContents.set(`meta/${slug}.md`, content);
+            }
+            else if (fm.type === "source") {
+                sources.push({
+                    slug,
+                    displayName: fm.name ?? slug,
+                    type: "source",
+                    author: fm.author ?? "",
+                    tags: fm.tags ?? [],
+                    hash,
+                    size,
+                });
+                this.frameworkContents.set(`sources/${slug}.md`, content);
+            }
+            else if (fm.type) {
+                const entry = {
+                    slug,
+                    displayName: fm.name ?? slug,
+                    type: fm.type,
+                    tags: fm.tags ?? [],
+                    hash,
+                    size,
+                };
+                if (fm.type === "antidote" && fm.mind_virus) {
+                    entry.mindVirus = fm.mind_virus;
+                }
+                if (fm.derived_from) {
+                    entry.derivedFrom = fm.derived_from;
+                }
+                nodes.push(entry);
+                this.frameworkContents.set(`nodes/${slug}.md`, content);
+            }
+        }
+        return { nodes, sources, meta };
+    }
+    /** Invalidate cached merged index (call after saving new files) */
+    invalidateIndex() {
+        this.mergedIndex = null;
+        this.localContents.clear();
+    }
+    async fetchNode(slug) {
+        const key = `nodes/${slug}.md`;
+        const local = this.localContents.get(key);
+        if (local)
+            return local;
+        const framework = this.frameworkContents.get(key);
+        if (framework)
+            return framework;
+        throw new Error(`Node "${slug}" not found in framework or local network.`);
+    }
+    async fetchSource(slug) {
+        const key = `sources/${slug}.md`;
+        const local = this.localContents.get(key);
+        if (local)
+            return local;
+        const framework = this.frameworkContents.get(key);
+        if (framework)
+            return framework;
+        throw new Error(`Source "${slug}" not found in framework or local network.`);
+    }
+    async fetchMeta(slug) {
+        const key = `meta/${slug}.md`;
+        const framework = this.frameworkContents.get(key);
+        if (framework)
+            return framework;
+        throw new Error(`Meta "${slug}" not found in framework.`);
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+export { NetworkFetcher, FRAMEWORK_SLUGS } from "./fetcher.js";
+export { search } from "./search.js";
+export { selectStartingFiles } from "./context.js";
+export { lint } from "./lint.js";
+export { generateReport } from "./report.js";
+export { appendLog, readLog, readLogRaw } from "./log.js";
+export { QUALITIES, ANTIDOTES } from "./constants.js";
+export type { NetworkIndex, NodeEntry, SourceEntry, MetaEntry, SearchResult, LintReport, LintIssue, ProductiveTension, DynamicLLMMode, LensId, QualityId, QualityDefinition, AntidoteDefinition, VirusAxisScore, ReportOptions, LogEntry, } from "./types.js";
+export type { Mode } from "./context.js";

package/dist/core/index.js

@@ -0,0 +1,8 @@
+// Core API — re-exports for package consumers
+export { NetworkFetcher, FRAMEWORK_SLUGS } from "./fetcher.js";
+export { search } from "./search.js";
+export { selectStartingFiles } from "./context.js";
+export { lint } from "./lint.js";
+export { generateReport } from "./report.js";
+export { appendLog, readLog, readLogRaw } from "./log.js";
+export { QUALITIES, ANTIDOTES } from "./constants.js";

package/dist/{lib → core}/lint.js

@@ -51,9 +51,6 @@ export function lint(index) {
     const orphanTags = [...tagCounts.entries()]
         .filter(([, count]) => count === 1)
         .map(([tag]) => tag);
-    // Productive Tensions: find node pairs that share multiple tags
-    // but represent different perspectives (different types or different people/ideas).
-    // These are features to surface, not errors to fix.
     const tensions = detectProductiveTensions(index.nodes);
     return {
         errors,
@@ -71,8 +68,6 @@ function detectProductiveTensions(nodes) {
         for (let j = i + 1; j < nodes.length; j++) {
             const a = nodes[i];
             const b = nodes[j];
-            // Only surface tensions between different types or between
-            // person↔person / idea↔idea pairs (where disagreement is meaningful)
             if (a.type === b.type && a.type !== "person" && a.type !== "idea" && a.type !== "synthesis") {
                 continue;
             }

package/dist/core/log.d.ts

@@ -0,0 +1,13 @@
+import type { LogEntry } from "./types.js";
+/** Append a timestamped entry to the local activity log */
+export declare function appendLog(action: string, slug: string, opts?: {
+    mode?: string;
+    summary?: string;
+}): void;
+/** Read and parse the activity log into structured entries */
+export declare function readLog(opts?: {
+    limit?: number;
+    action?: string;
+}): LogEntry[];
+/** Get the raw log content */
+export declare function readLogRaw(): string;

package/dist/core/log.js

@@ -0,0 +1,65 @@
+import { existsSync, mkdirSync, readFileSync, appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const LOG_DIR = join(homedir(), ".dynamicllm");
+const LOG_PATH = join(LOG_DIR, "log.md");
+/** Append a timestamped entry to the local activity log */
+export function appendLog(action, slug, opts) {
+    if (!existsSync(LOG_DIR))
+        mkdirSync(LOG_DIR, { recursive: true });
+    const now = new Date();
+    const date = now.toISOString().slice(0, 10);
+    const timestamp = now.toISOString();
+    let entry = `\n## [${date}] ${action} | "${slug}"`;
+    if (opts?.mode)
+        entry += ` | mode: ${opts.mode}`;
+    if (opts?.summary)
+        entry += `\n${opts.summary}`;
+    entry += `\n<!-- ts:${timestamp} action:${action} slug:${slug}${opts?.mode ? ` mode:${opts.mode}` : ""} -->`;
+    entry += "\n";
+    appendFileSync(LOG_PATH, entry, "utf-8");
+}
+/** Read and parse the activity log into structured entries */
+export function readLog(opts) {
+    if (!existsSync(LOG_PATH))
+        return [];
+    const content = readFileSync(LOG_PATH, "utf-8");
+    const entries = [];
+    // Parse structured comment lines
+    const commentRegex = /<!-- ts:(\S+) action:(\S+) slug:(\S+)(?: mode:(\S+))? -->/g;
+    let match;
+    while ((match = commentRegex.exec(content)) !== null) {
+        const entry = {
+            date: match[1].slice(0, 10),
+            timestamp: match[1],
+            action: match[2],
+            slug: match[3],
+        };
+        if (match[4])
+            entry.mode = match[4];
+        // Extract summary from the line before the comment
+        const before = content.slice(0, match.index);
+        const lastNewline = before.lastIndexOf("\n");
+        const secondLastNewline = before.lastIndexOf("\n", lastNewline - 1);
+        if (lastNewline > secondLastNewline + 1) {
+            const summaryLine = before.slice(secondLastNewline + 1, lastNewline).trim();
+            if (summaryLine && !summaryLine.startsWith("##")) {
+                entry.summary = summaryLine;
+            }
+        }
+        if (opts?.action && entry.action !== opts.action)
+            continue;
+        entries.push(entry);
+    }
+    // Most recent first
+    entries.reverse();
+    if (opts?.limit)
+        return entries.slice(0, opts.limit);
+    return entries;
+}
+/** Get the raw log content */
+export function readLogRaw() {
+    if (!existsSync(LOG_PATH))
+        return "";
+    return readFileSync(LOG_PATH, "utf-8");
+}