obsidian-second-brain 0.1.0

package/dist/render-claude-jsonl.js

@@ -0,0 +1,179 @@
+import { basename } from "node:path";
+export function renderClaudeJsonlToMarkdown(input) {
+    const events = parseEvents(input.sourceContent);
+    const title = extractTitle(events, input.relativePath);
+    const sessionId = extractSessionId(events);
+    const cwd = extractCwd(events);
+    const sessionStartedAt = extractSessionStartedAt(events);
+    const turns = extractConversationTurns(events);
+    const header = buildHeader({ cwd, generatedAt: input.generatedAt, relativePath: input.relativePath, sessionId, title });
+    const body = turns.length > 0 ? buildConversation(turns) : "_No conversation turns found._";
+    return {
+        markdown: [header, "", "## Conversation", "", body].join("\n"),
+        metadata: { cwd, sessionId, sessionStartedAt }
+    };
+}
+function parseEvents(sourceContent) {
+    return sourceContent
+        .split("\n")
+        .flatMap((line) => {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            return [];
+        }
+        try {
+            const value = JSON.parse(trimmed);
+            if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                return [value];
+            }
+            return [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function extractTitle(events, relativePath) {
+    const titleEvent = events.find((e) => e.type === "ai-title");
+    if (titleEvent && typeof titleEvent.aiTitle === "string" && titleEvent.aiTitle.trim().length > 0) {
+        // The title is model-generated free text: collapse whitespace so an
+        // embedded newline cannot break the H1 and inject fake header lines.
+        return titleEvent.aiTitle.replaceAll(/\s+/gu, " ").trim();
+    }
+    return basename(relativePath).replace(/\.jsonl$/u, "");
+}
+function extractSessionId(events) {
+    for (const event of events) {
+        if (typeof event.sessionId === "string") {
+            return event.sessionId;
+        }
+    }
+    return undefined;
+}
+function extractSessionStartedAt(events) {
+    for (const event of events) {
+        if (typeof event.timestamp === "string") {
+            return event.timestamp;
+        }
+    }
+    return undefined;
+}
+function extractCwd(events) {
+    for (const event of events) {
+        if (event.type === "user" && typeof event.cwd === "string") {
+            return event.cwd;
+        }
+    }
+    return undefined;
+}
+function extractConversationTurns(events) {
+    const turns = [];
+    for (const event of events) {
+        const type = event.type;
+        if (type !== "user" && type !== "assistant") {
+            continue;
+        }
+        const msg = event.message;
+        if (typeof msg !== "object" || msg === null || Array.isArray(msg)) {
+            continue;
+        }
+        const message = msg;
+        const role = message.role;
+        if (role !== "user" && role !== "assistant") {
+            continue;
+        }
+        const timestamp = typeof event.timestamp === "string" ? event.timestamp : "unknown";
+        const content = message.content;
+        const blocks = extractContentBlocks(content);
+        if (blocks.length > 0) {
+            turns.push({ blocks, cwd: undefined, role, timestamp });
+        }
+    }
+    return turns;
+}
+function extractContentBlocks(content) {
+    if (typeof content === "string") {
+        return [{ text: content, type: "text" }];
+    }
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    return content.flatMap((item) => {
+        if (typeof item !== "object" || item === null) {
+            return [];
+        }
+        const block = item;
+        const blockType = typeof block.type === "string" ? block.type : "unknown";
+        if (blockType === "thinking") {
+            return [];
+        }
+        if (blockType === "text" && typeof block.text === "string") {
+            return [{ text: block.text, type: "text" }];
+        }
+        if (blockType === "tool_use") {
+            return [{
+                    input: block.input,
+                    name: typeof block.name === "string" ? block.name : "unknown",
+                    type: "tool_use"
+                }];
+        }
+        if (blockType === "tool_result") {
+            return [];
+        }
+        return [];
+    });
+}
+function buildHeader(input) {
+    const lines = [`# ${input.title}`, ""];
+    lines.push(`- source: ${input.relativePath}`);
+    if (input.sessionId) {
+        lines.push(`- session_id: ${input.sessionId}`);
+    }
+    if (input.cwd) {
+        lines.push(`- cwd: ${input.cwd}`);
+    }
+    lines.push(`- generated_at: ${input.generatedAt}`);
+    return lines.join("\n");
+}
+function buildConversation(turns) {
+    return turns
+        .map((turn) => renderTurn(turn))
+        .join("\n\n---\n\n");
+}
+function renderTurn(turn) {
+    const label = turn.role === "user" ? "**User**" : "**Assistant**";
+    const heading = `${label} · ${turn.timestamp}`;
+    const body = turn.blocks.map((block) => renderBlock(block)).join("\n\n");
+    return [heading, "", body].join("\n");
+}
+function renderBlock(block) {
+    if (block.type === "text" && block.text !== undefined) {
+        return block.text;
+    }
+    if (block.type === "tool_use") {
+        const name = block.name ?? "unknown";
+        const inputSummary = summarizeInput(block.input);
+        return `> \`${name}\` → ${inputSummary}`;
+    }
+    return "";
+}
+function summarizeInput(input) {
+    if (input === null || input === undefined) {
+        return "(no input)";
+    }
+    if (typeof input === "string") {
+        return input.length > 120 ? `${input.slice(0, 120)}…` : input;
+    }
+    if (typeof input === "object" && !Array.isArray(input)) {
+        const entries = Object.entries(input);
+        if (entries.length === 1) {
+            const [key, value] = entries[0];
+            const valueStr = typeof value === "string" ? value : JSON.stringify(value);
+            const truncated = valueStr.length > 100 ? `${valueStr.slice(0, 100)}…` : valueStr;
+            return `${key}: ${truncated}`;
+        }
+        const compact = JSON.stringify(input);
+        return compact.length > 150 ? `${compact.slice(0, 150)}…` : compact;
+    }
+    return String(input);
+}

package/dist/render-jsonl-markdown.js

@@ -0,0 +1,116 @@
+import { basename } from "node:path";
+export function renderJsonlToMarkdown(input) {
+    const lines = input.sourceContent
+        // A UTF-8 BOM is not JSON whitespace: without this strip the first event
+        // would render as malformed AND silently lose its session metadata.
+        .replace(/^\uFEFF/u, "")
+        .split("\n")
+        .map((line, index) => ({ line, lineNumber: index + 1 }))
+        .filter(({ line }) => line.trim().length > 0);
+    const events = lines.flatMap(({ line }) => {
+        try {
+            const value = JSON.parse(line);
+            return isJsonObject(value) ? [value] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    const sections = lines
+        .map(({ line, lineNumber }) => renderLine(line, lineNumber))
+        .join("\n\n");
+    const title = basename(input.relativePath).replace(/\.jsonl$/u, "") || "session";
+    const markdown = [
+        `# ${title}`,
+        "",
+        `- provider: ${input.providerName}`,
+        `- source: ${input.relativePath}`,
+        `- generated_at: ${input.generatedAt}`,
+        `- source_type: jsonl`,
+        "",
+        sections
+    ].join("\n");
+    return { markdown, metadata: extractMetadata(events) };
+}
+function extractMetadata(events) {
+    const findString = (pick) => {
+        for (const event of events) {
+            const value = pick(event);
+            if (typeof value === "string") {
+                return value;
+            }
+        }
+        return undefined;
+    };
+    return {
+        cwd: findString((event) => event.cwd),
+        sessionId: findString((event) => event.sessionId ?? event.session_id),
+        sessionStartedAt: findString((event) => event.timestamp)
+    };
+}
+function renderLine(line, lineNumber) {
+    try {
+        const value = JSON.parse(line);
+        if (!isJsonObject(value)) {
+            return renderMalformedLine(line, lineNumber);
+        }
+        const timestamp = typeof value.timestamp === "string" ? value.timestamp : "unknown";
+        const type = typeof value.type === "string" ? value.type : "unknown";
+        const text = extractText(value);
+        return [
+            `## Event ${lineNumber}: ${type}`,
+            "",
+            `- timestamp: ${timestamp}`,
+            "",
+            text ?? "_No direct text content_",
+            "",
+            "```json",
+            JSON.stringify(value, null, 2),
+            "```"
+        ].join("\n");
+    }
+    catch {
+        return renderMalformedLine(line, lineNumber);
+    }
+}
+function extractText(value) {
+    if (typeof value.text === "string") {
+        return value.text;
+    }
+    const msg = value.message;
+    if (!isJsonObject(msg)) {
+        return undefined;
+    }
+    const content = msg.content;
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const texts = content
+            .filter((block) => isJsonObject(block) && typeof block.text === "string")
+            .map((block) => block.text);
+        return texts.length > 0 ? texts.join("\n\n") : undefined;
+    }
+    return undefined;
+}
+function renderMalformedLine(line, lineNumber) {
+    const fence = createMarkdownFence(line);
+    return [
+        `## Event ${lineNumber}: malformed`,
+        "",
+        `- error: Malformed JSONL line ${lineNumber}`,
+        "",
+        `${fence}text`,
+        line,
+        fence
+    ].join("\n");
+}
+function createMarkdownFence(content) {
+    const longestRun = content.match(/`+/gu)?.reduce((longest, run) => {
+        return Math.max(longest, run.length);
+    }, 0) ?? 0;
+    return "`".repeat(Math.max(3, longestRun + 1));
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/report.js

@@ -0,0 +1,244 @@
+import { lstat, readdir, readFile, rm } from "node:fs/promises";
+import { basename, isAbsolute, relative, resolve } from "node:path";
+import { ensureDirectory, writeFileAtomic } from "./filesystem.js";
+// Reports are regenerable noise, not an audit trail (vault git history covers
+// that), so old ones are pruned instead of accumulating forever.
+const REPORT_RETENTION_LIMIT = 50;
+const REPORT_FILE_PATTERN = /^(\d{4}-\d{2}-\d{2}-\d{4}-(?:hourly|manual|weekly))(?:-(\d+))?\.md$/u;
+// The rendered transcript opens with its "# title" line; scanning further
+// would start matching headings inside quoted conversation content.
+const TITLE_SCAN_LIMIT = 10;
+export function createReportWriter(input) {
+    // A combined --ingest --consolidate run produces ONE report: each stage call
+    // rebuilds the full document from accumulated state and rewrites the same
+    // file, so no stage ever has to parse frontmatter it wrote earlier.
+    const state = {};
+    const write = async () => {
+        await ensureDirectory(input.reportsRoot);
+        const createdAt = state.createdAt ?? input.now();
+        state.createdAt = createdAt;
+        state.reportPath =
+            state.reportPath ??
+                (await claimReportPath(input.reportsRoot, createdAt, input.runKind));
+        const content = await buildReportContent({
+            consolidation: state.consolidation,
+            createdAt,
+            ingest: state.ingest,
+            runKind: input.runKind,
+            vaultRoot: input.vaultRoot
+        });
+        await writeFileAtomic(state.reportPath, content);
+        try {
+            await pruneReports(input.reportsRoot, state.reportPath);
+        }
+        catch {
+            // Retention is janitorial: a failed delete of an old, disposable report
+            // must never abort the run — that would block the manifest advance and
+            // force paid re-synthesis of work that already succeeded.
+        }
+        return {
+            path: state.reportPath,
+            wikiLink: `reports/${basename(state.reportPath).replace(/\.md$/u, "")}`
+        };
+    };
+    return {
+        addConsolidation: async (data) => {
+            state.consolidation = data;
+            return write();
+        },
+        addIngest: async (data) => {
+            state.ingest = data;
+            return write();
+        }
+    };
+}
+async function buildReportContent(input) {
+    const iso = input.createdAt.toISOString();
+    const lines = ["---", "type: report", `date: ${iso}`, `run: ${input.runKind}`];
+    if (input.ingest) {
+        lines.push(`transcripts_added: ${input.ingest.transcriptsAdded.length}`, `transcripts_changed: ${input.ingest.transcriptsChanged.length}`, `artifacts_ingested: ${input.ingest.artifacts.length}`, `episodes_created: ${input.ingest.episodes.length}`, `ingest_failures: ${input.ingest.failures.length}`, `artifacts_quarantined: ${input.ingest.quarantined.length}`);
+    }
+    if (input.consolidation) {
+        lines.push(`pages_created: ${input.consolidation.pagesCreated.length}`, `pages_updated: ${input.consolidation.pagesUpdated.length}`, `episodes_consolidated: ${input.consolidation.episodesConsolidated}`, `consolidation_failures: ${input.consolidation.failures.length}`, `episodes_quarantined: ${input.consolidation.quarantined.length}`);
+    }
+    const stamp = `${iso.slice(0, 10)} ${iso.slice(11, 16)} UTC`;
+    lines.push("---", "", `# Sync run ${stamp} (${input.runKind})`);
+    if (input.ingest) {
+        lines.push("", ...(await buildIngestSection(input.ingest, input.vaultRoot)));
+    }
+    if (input.consolidation) {
+        lines.push("", ...buildConsolidationSection(input.consolidation));
+    }
+    return `${lines.join("\n")}\n`;
+}
+async function buildIngestSection(data, vaultRoot) {
+    const lines = ["## Ingest"];
+    const projects = [
+        ...new Set([...data.transcriptsAdded, ...data.transcriptsChanged, ...data.artifacts, ...data.episodes].map((item) => item.project))
+    ].sort();
+    for (const project of projects) {
+        lines.push("", `### ${project}`);
+        const added = data.transcriptsAdded.filter((item) => item.project === project);
+        const changed = data.transcriptsChanged.filter((item) => item.project === project);
+        const artifacts = data.artifacts.filter((item) => item.project === project);
+        const episodes = data.episodes.filter((item) => item.project === project);
+        if (added.length > 0) {
+            lines.push("", "New transcripts:");
+            for (const transcript of added) {
+                lines.push(`- ${await transcriptLine(transcript, vaultRoot)}`);
+            }
+        }
+        if (changed.length > 0) {
+            lines.push("", "Changed transcripts:");
+            for (const transcript of changed) {
+                lines.push(`- ${await transcriptLine(transcript, vaultRoot)}`);
+            }
+        }
+        if (artifacts.length > 0) {
+            lines.push("", "Artifacts ingested:");
+            for (const artifact of artifacts) {
+                lines.push(`- ${artifact.type} — ${vaultLink(artifact.path, vaultRoot, basename(artifact.path))}`);
+            }
+        }
+        if (episodes.length > 0) {
+            lines.push("", "Episodes created:");
+            for (const episode of episodes) {
+                lines.push(`- [[episodes/${basename(episode.path).replace(/\.md$/u, "")}]]`);
+            }
+        }
+    }
+    if (data.failures.length > 0) {
+        lines.push("", "### Failures", "");
+        for (const failure of data.failures) {
+            lines.push(`- ${failure.project} — ${failure.reason}`);
+        }
+    }
+    if (data.quarantined.length > 0) {
+        lines.push("", "### Quarantined artifacts", "");
+        for (const artifact of data.quarantined) {
+            lines.push(`- \`${artifact.path}\` — ${artifact.reason}`);
+        }
+    }
+    return lines;
+}
+function buildConsolidationSection(data) {
+    const lines = ["## Consolidation", ""];
+    if (data.pagesCreated.length > 0) {
+        lines.push(`Pages created: ${data.pagesCreated.map((page) => `[[${page}]]`).join(", ")}`);
+    }
+    if (data.pagesUpdated.length > 0) {
+        lines.push(`Pages updated: ${data.pagesUpdated.map((page) => `[[${page}]]`).join(", ")}`);
+    }
+    lines.push(`Episodes consolidated: ${data.episodesConsolidated}`);
+    if (data.skippedProjects.length > 0) {
+        lines.push(`Projects skipped by the backend: ${data.skippedProjects.join(", ")}`);
+    }
+    if (data.failures.length > 0) {
+        lines.push("", "### Failures", "");
+        for (const failure of data.failures) {
+            lines.push(`- ${failure.project} — ${failure.reason}`);
+        }
+    }
+    if (data.quarantined.length > 0) {
+        lines.push("", "### Quarantined episodes", "");
+        for (const episode of data.quarantined) {
+            lines.push(`- \`${episode.path}\` — ${episode.reason}`);
+        }
+    }
+    return lines;
+}
+async function transcriptLine(transcript, vaultRoot) {
+    const title = await readTranscriptTitle(transcript.path);
+    return `${vaultLink(transcript.path, vaultRoot, title)} (${transcript.provider})`;
+}
+async function readTranscriptTitle(path) {
+    const fallback = basename(path).replace(/\.md$/u, "");
+    let content;
+    try {
+        content = await readFile(path, "utf8");
+    }
+    catch {
+        // A transcript pruned between sync and report must degrade to the
+        // filename, not fail the whole run over a cosmetic title.
+        return fallback;
+    }
+    for (const line of content.split("\n", TITLE_SCAN_LIMIT)) {
+        const match = /^# (.+)$/u.exec(line);
+        if (match) {
+            const title = match[1].trim();
+            return title.length > 0 ? title : fallback;
+        }
+    }
+    return fallback;
+}
+function vaultLink(path, vaultRoot, alias) {
+    const relativePath = relative(vaultRoot, path);
+    if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+        // Outside the vault there is nothing for Obsidian to resolve.
+        return `\`${path}\``;
+    }
+    const target = relativePath.replace(/\.md$/u, "");
+    const safeAlias = alias.replaceAll(/[[\]|]/gu, " ").replaceAll(/\s+/gu, " ").trim();
+    return safeAlias.length > 0 ? `[[${target}|${safeAlias}]]` : `[[${target}]]`;
+}
+async function claimReportPath(reportsRoot, createdAt, runKind) {
+    const iso = createdAt.toISOString();
+    const stamp = `${iso.slice(0, 10)}-${iso.slice(11, 13)}${iso.slice(14, 16)}`;
+    const baseName = `${stamp}-${runKind}`;
+    for (let suffix = 1; suffix <= 50; suffix += 1) {
+        const name = suffix === 1 ? `${baseName}.md` : `${baseName}-${suffix}.md`;
+        const candidate = resolve(reportsRoot, name);
+        if (!(await pathExists(candidate))) {
+            return candidate;
+        }
+    }
+    throw new Error(`Could not find a free report filename for ${baseName}`);
+}
+async function pruneReports(reportsRoot, keepPath) {
+    const entries = await readdir(reportsRoot);
+    const stale = entries
+        .filter((name) => REPORT_FILE_PATTERN.test(name))
+        .sort(compareReportNames)
+        .reverse()
+        .slice(REPORT_RETENTION_LIMIT);
+    for (const name of stale) {
+        const target = resolve(reportsRoot, name);
+        if (target === keepPath) {
+            continue;
+        }
+        await rm(target, { force: true });
+    }
+}
+function compareReportNames(a, b) {
+    const matchA = REPORT_FILE_PATTERN.exec(a);
+    const matchB = REPORT_FILE_PATTERN.exec(b);
+    // Callers filter on the pattern first; this guard only keeps exec honest.
+    if (!matchA || !matchB) {
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+    // The stamp+kind prefix sorts lexicographically, but the same-minute
+    // collision suffix is an unpadded integer and must compare numerically
+    // ("-10" is newer than "-2", and no suffix means the first write).
+    if (matchA[1] !== matchB[1]) {
+        return matchA[1] < matchB[1] ? -1 : 1;
+    }
+    return Number(matchA[2] ?? "1") - Number(matchB[2] ?? "1");
+}
+async function pathExists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return false;
+        }
+        return true;
+    }
+}
+function isMissingFileError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        error.code === "ENOENT");
+}

package/dist/shell.js

@@ -0,0 +1,84 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function runCommand(command, args, cwd, env) {
+    try {
+        const result = await execFileAsync(command, [...args], {
+            cwd,
+            encoding: "utf8",
+            ...(env === undefined ? {} : { env: { ...env } }),
+            maxBuffer: 10 * 1024 * 1024
+        });
+        return {
+            stderr: result.stderr,
+            stdout: result.stdout
+        };
+    }
+    catch (error) {
+        throw new Error(buildCommandError(command, args, error));
+    }
+}
+export async function runCommandAllowFailure(command, args, cwd) {
+    try {
+        const result = await execFileAsync(command, [...args], {
+            cwd,
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024
+        });
+        return {
+            exitCode: 0,
+            stderr: result.stderr,
+            stdout: result.stdout
+        };
+    }
+    catch (error) {
+        const normalizedError = error;
+        return {
+            exitCode: typeof normalizedError.code === "number" ? normalizedError.code : 1,
+            stderr: normalizedError.stderr ?? "",
+            stdout: normalizedError.stdout ?? ""
+        };
+    }
+}
+// Long prompts are passed as argv: echoing them whole made failure reasons
+// unreadable, while the actual diagnostic (exit code, spawn error, stream
+// tails) was missing entirely.
+const ARGS_PREVIEW_LIMIT = 160;
+const STREAM_TAIL_LIMIT = 400;
+function buildCommandError(command, args, error) {
+    const normalizedError = error;
+    const lines = [`Command failed: ${command} ${previewArgs(args)}`.trimEnd()];
+    if (typeof normalizedError.code === "string") {
+        // Spawn-layer failures (ENOENT, EACCES) never start the child: the node
+        // error message is the only diagnostic there is.
+        lines.push(normalizedError.message);
+    }
+    else if (typeof normalizedError.code === "number") {
+        lines.push(`exit code ${normalizedError.code}`);
+    }
+    else if (typeof normalizedError.signal === "string") {
+        lines.push(`killed by signal ${normalizedError.signal}`);
+    }
+    const stderrTail = streamTail(normalizedError.stderr);
+    if (stderrTail !== "") {
+        lines.push(`stderr: ${stderrTail}`);
+    }
+    // claude -p reports usage limits and API errors on stdout, not stderr.
+    const stdoutTail = streamTail(normalizedError.stdout);
+    if (stdoutTail !== "") {
+        lines.push(`stdout: ${stdoutTail}`);
+    }
+    return lines.join("\n");
+}
+function previewArgs(args) {
+    const joined = args.join(" ");
+    return joined.length <= ARGS_PREVIEW_LIMIT
+        ? joined
+        : `${joined.slice(0, ARGS_PREVIEW_LIMIT)}... (+${joined.length - ARGS_PREVIEW_LIMIT} chars)`;
+}
+function streamTail(stream) {
+    const trimmed = stream?.trim() ?? "";
+    return trimmed.length <= STREAM_TAIL_LIMIT
+        ? trimmed
+        : `... ${trimmed.slice(-STREAM_TAIL_LIMIT)}`;
+}

package/dist/slug.js

@@ -0,0 +1,16 @@
+const slugPattern = /^[a-z0-9][a-z0-9-]*$/u;
+export function isSlug(value) {
+    return slugPattern.test(value);
+}
+export function isProjectSegment(value) {
+    // _inbox is the reserved capture fallback and the only non-slug segment.
+    return value === "_inbox" || isSlug(value);
+}
+export function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[\s_]+/gu, "-")
+        .replace(/[^a-z0-9-]/gu, "")
+        .replace(/-{2,}/gu, "-")
+        .replace(/^-+|-+$/gu, "");
+}