@alexzeitler/session-md 0.5.0

package/src/components/StatusBar.ts

@@ -0,0 +1,70 @@
+import {
+  BoxRenderable,
+  TextRenderable,
+  type CliRenderer,
+  t,
+  fg,
+  bold,
+} from "@opentui/core";
+import type { Theme } from "../theme.ts";
+
+export type FocusArea = "sidebar" | "main";
+
+export class StatusBar {
+  readonly container: BoxRenderable;
+  private statusText: TextRenderable;
+  private msgText: TextRenderable;
+
+  constructor(private ctx: CliRenderer, private theme: Theme) {
+    this.container = new BoxRenderable(ctx, {
+      id: "status-bar",
+      height: 3,
+      width: "100%" as any,
+      borderStyle: "rounded",
+      borderColor: this.theme.border_inactive,
+      flexDirection: "row",
+      justifyContent: "space-between",
+    });
+
+    this.statusText = new TextRenderable(ctx, {
+      id: "status-text",
+      content: "",
+      paddingLeft: 1,
+    });
+
+    this.msgText = new TextRenderable(ctx, {
+      id: "msg-text",
+      content: "",
+      paddingRight: 1,
+    });
+
+    this.container.add(this.statusText);
+    this.container.add(this.msgText);
+  }
+
+  update(selectedCount: number, totalCount: number, focus: FocusArea): void {
+    const selPrefix =
+      selectedCount > 0 ? `${selectedCount} selected | ` : "";
+
+    const hint =
+      focus === "sidebar"
+        ? "j/k navigate  gg/G top/end  SPACE select  c copy  / filter  g grep  q quit"
+        : "j/k scroll  gg/G top/end  Esc back  q quit";
+
+    this.statusText.content = t`${fg(this.theme.success)(selPrefix)}${fg(this.theme.muted)(`${totalCount} sessions`)} | ${fg(this.theme.muted)(hint)}`;
+  }
+
+  showError(msg: string): void {
+    this.msgText.content = t`${fg(this.theme.error)(msg)}`;
+    setTimeout(() => {
+      this.msgText.content = "";
+    }, 5000);
+  }
+
+  showInfo(msg: string): void {
+    this.msgText.content = t`${fg(this.theme.success)(msg)}`;
+    setTimeout(() => {
+      this.msgText.content = "";
+    }, 3000);
+  }
+}

package/src/components/TargetPicker.ts

@@ -0,0 +1,174 @@
+import {
+  BoxRenderable,
+  SelectRenderable,
+  SelectRenderableEvents,
+  TextRenderable,
+  InputRenderable,
+  InputRenderableEvents,
+  type SelectOption,
+  type CliRenderer,
+  t,
+  fg,
+  bold,
+} from "@opentui/core";
+import type { Theme } from "../theme.ts";
+
+export class TargetPicker {
+  readonly container: BoxRenderable;
+  readonly select: SelectRenderable;
+  private headerText: TextRenderable;
+  private nameInput: InputRenderable;
+  private pathInput: InputRenderable;
+  private inputContainer: BoxRenderable;
+  private enteringNew = false;
+  private inputStep: "path" | "name" = "path";
+
+  onTargetSelected: ((targetPath: string) => void) | null = null;
+  onNewTarget: ((name: string, path: string) => void) | null = null;
+  onCancel: (() => void) | null = null;
+
+  constructor(private ctx: CliRenderer, private theme?: Theme) {
+    this.container = new BoxRenderable(ctx, {
+      id: "target-picker",
+      flexDirection: "column",
+      flexGrow: 1,
+      padding: 1,
+      gap: 1,
+    });
+
+    this.headerText = new TextRenderable(ctx, {
+      id: "target-header",
+      content: "",
+    });
+
+    this.select = new SelectRenderable(ctx, {
+      id: "target-select",
+      flexGrow: 1,
+      options: [],
+      showDescription: true,
+      wrapSelection: true,
+      selectedBackgroundColor: this.theme?.selection_bg ?? "#264f78",
+      selectedTextColor: this.theme?.selection_fg ?? "#ffffff",
+      selectedDescriptionColor: this.theme?.selection_desc ?? "#a0c4e8",
+    });
+
+    this.inputContainer = new BoxRenderable(ctx, {
+      id: "target-input-container",
+      flexDirection: "column",
+      gap: 1,
+      padding: 1,
+    });
+
+    const pathLabel = new TextRenderable(ctx, {
+      id: "target-path-label",
+      content: t`${bold("Path:")}`,
+    });
+
+    this.pathInput = new InputRenderable(ctx, {
+      id: "target-path-input",
+      width: 60,
+      placeholder: "~/path/to/folder",
+    });
+
+    const nameLabel = new TextRenderable(ctx, {
+      id: "target-name-label",
+      content: t`${bold("Name (optional):")}`,
+    });
+
+    this.nameInput = new InputRenderable(ctx, {
+      id: "target-name-input",
+      width: 30,
+      placeholder: "short name",
+    });
+
+    this.inputContainer.add(pathLabel);
+    this.inputContainer.add(this.pathInput);
+    this.inputContainer.add(nameLabel);
+    this.inputContainer.add(this.nameInput);
+
+    this.container.add(this.headerText);
+    this.container.add(this.select);
+
+    this.select.on(
+      SelectRenderableEvents.ITEM_SELECTED,
+      (_index: number, option: SelectOption) => {
+        if (option.value === "__new__") {
+          this.showNewTargetInput();
+        } else if (this.onTargetSelected) {
+          this.onTargetSelected(option.value);
+        }
+      },
+    );
+
+    this.pathInput.on(InputRenderableEvents.ENTER, () => {
+      this.nameInput.focus();
+    });
+
+    this.nameInput.on(InputRenderableEvents.ENTER, () => {
+      const path = this.pathInput.value.trim();
+      if (!path) return;
+      const name = this.nameInput.value.trim();
+      if (this.onNewTarget) {
+        this.onNewTarget(name, path);
+      }
+    });
+  }
+
+  show(targets: Record<string, string>, fileCount: number): void {
+    this.enteringNew = false;
+    this.headerText.content = t`${bold(`Copy ${fileCount} file(s) to...`)}`;
+
+    const options: SelectOption[] = Object.entries(targets).map(
+      ([name, path]) => ({
+        name,
+        description: path,
+        value: path,
+      }),
+    );
+    options.push({
+      name: "[+ new folder...]",
+      description: "",
+      value: "__new__",
+    });
+
+    this.select.options = options;
+  }
+
+  private showNewTargetInput(): void {
+    this.enteringNew = true;
+    this.container.remove(this.select.id);
+    this.container.add(this.inputContainer);
+    this.pathInput.value = "";
+    this.nameInput.value = "";
+    this.pathInput.focus();
+  }
+
+  hideNewTargetInput(): void {
+    if (this.enteringNew) {
+      this.enteringNew = false;
+      this.container.remove(this.inputContainer.id);
+      this.container.add(this.select);
+      this.select.focus();
+    }
+  }
+
+  isEnteringNew(): boolean {
+    return this.enteringNew;
+  }
+
+  focus(): void {
+    if (this.enteringNew) {
+      this.pathInput.focus();
+    } else {
+      this.select.focus();
+    }
+  }
+
+  reset(): void {
+    this.enteringNew = false;
+    this.pathInput.value = "";
+    this.nameInput.value = "";
+    this.headerText.content = "";
+    this.select.options = [];
+  }
+}

package/src/config.ts

@@ -0,0 +1,85 @@
+import { parse, stringify } from "smol-toml";
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+
+const CONFIG_DIR = join(homedir(), ".config", "session-md");
+const CONFIG_PATH = join(CONFIG_DIR, "config.toml");
+
+export interface Config {
+  default_target: string;
+  targets: Record<string, string>;
+  sources: {
+    claude_code?: string;
+    opencode?: string;
+    claude_export?: string;
+    memorizer_url?: string;
+    memorizer_output?: string;
+  };
+  theme?: Record<string, string>;
+}
+
+const DEFAULT_CONFIG: Config = {
+  default_target: join(homedir(), "notes", "claude-chats"),
+  targets: {
+    vault: join(homedir(), "notes", "claude-chats"),
+  },
+  sources: {
+    claude_code: join(homedir(), ".claude", "projects"),
+    opencode: join(homedir(), ".local", "share", "opencode", "storage"),
+  },
+};
+
+function expandTilde(p: string): string {
+  if (p.startsWith("~/") || p === "~") {
+    return join(homedir(), p.slice(1));
+  }
+  return p;
+}
+
+function expandPaths(config: Config): Config {
+  config.default_target = expandTilde(config.default_target);
+
+  for (const [key, val] of Object.entries(config.targets)) {
+    config.targets[key] = expandTilde(val);
+  }
+
+  const sources = config.sources;
+  if (sources.claude_code) sources.claude_code = expandTilde(sources.claude_code);
+  if (sources.opencode) sources.opencode = expandTilde(sources.opencode);
+  if (sources.claude_export) sources.claude_export = expandTilde(sources.claude_export);
+  if (sources.memorizer_output)
+    sources.memorizer_output = expandTilde(sources.memorizer_output);
+
+  return config;
+}
+
+export async function loadConfig(): Promise<Config> {
+  if (!existsSync(CONFIG_PATH)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    await Bun.write(CONFIG_PATH, stringify(DEFAULT_CONFIG as any));
+    return expandPaths({ ...DEFAULT_CONFIG });
+  }
+
+  const raw = await Bun.file(CONFIG_PATH).text();
+  const parsed = parse(raw) as unknown as Config;
+
+  const config: Config = {
+    default_target: parsed.default_target ?? DEFAULT_CONFIG.default_target,
+    targets: parsed.targets ?? DEFAULT_CONFIG.targets,
+    sources: { ...DEFAULT_CONFIG.sources, ...parsed.sources },
+    theme: (parsed as any).theme ?? undefined,
+  };
+
+  return expandPaths(config);
+}
+
+export async function addTarget(name: string, path: string): Promise<void> {
+  const raw = await Bun.file(CONFIG_PATH).text();
+  const parsed = parse(raw) as any;
+
+  if (!parsed.targets) parsed.targets = {};
+  parsed.targets[name] = path;
+
+  await Bun.write(CONFIG_PATH, stringify(parsed));
+}

package/src/file-ops.ts

@@ -0,0 +1,23 @@
+import { join, dirname } from "path";
+import { mkdirSync, existsSync } from "fs";
+import type { SessionEntry } from "./import/types.ts";
+import { loadSessionMarkdownSync } from "./import/loader.ts";
+
+export async function copySessionsToTarget(
+  sessions: SessionEntry[],
+  targetPath: string,
+): Promise<void> {
+  mkdirSync(targetPath, { recursive: true });
+
+  for (const session of sessions) {
+    const md = loadSessionMarkdownSync(session);
+    const dest = join(targetPath, session.filename);
+    const destDir = dirname(dest);
+
+    if (!existsSync(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+
+    await Bun.write(dest, md);
+  }
+}

package/src/import/claude-code-to-md.ts

@@ -0,0 +1,184 @@
+import { join, basename, dirname } from "path";
+import { readdirSync, existsSync, statSync, readFileSync } from "fs";
+import {
+  type SessionEntry,
+  type SessionMeta,
+  buildFrontmatter,
+  formatDate,
+  truncateTitle,
+} from "./types.ts";
+
+interface ContentBlock {
+  type: string;
+  text?: string;
+  thinking?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: ContentBlock[];
+}
+
+function extractTextFromContent(
+  content: string | ContentBlock[],
+): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+
+  const parts: string[] = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      parts.push(block.text);
+    } else if (block.type === "tool_use" && block.name) {
+      const inputStr = block.input
+        ? JSON.stringify(block.input, null, 2)
+        : "";
+      parts.push(`> **Tool**: ${block.name}\n> \`\`\`\n> ${inputStr}\n> \`\`\``);
+    }
+  }
+  return parts.join("\n\n");
+}
+
+/**
+ * Fast scan: only reads first few lines to extract title, no full parse.
+ */
+export function scanClaudeCodeSessions(
+  sourcePath: string,
+): SessionEntry[] {
+  if (!existsSync(sourcePath)) return [];
+
+  const entries: SessionEntry[] = [];
+
+  const projectDirs = readdirSync(sourcePath, { withFileTypes: true })
+    .filter((d) => d.isDirectory());
+
+  for (const projDir of projectDirs) {
+    const projPath = join(sourcePath, projDir.name);
+    let jsonlFiles: string[];
+    try {
+      jsonlFiles = readdirSync(projPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+
+    for (const file of jsonlFiles) {
+      const filePath = join(projPath, file);
+      const sessionId = basename(file, ".jsonl");
+
+      try {
+        const stat = statSync(filePath);
+        if (stat.size === 0) continue;
+
+        // Quick title extraction: read first ~4KB, find first user message
+        const fd = require("fs").openSync(filePath, "r");
+        const buf = Buffer.alloc(Math.min(stat.size, 4096));
+        require("fs").readSync(fd, buf, 0, buf.length, 0);
+        require("fs").closeSync(fd);
+
+        let title = `Session ${sessionId.slice(0, 8)}`;
+        const chunk = buf.toString("utf-8");
+        const lines = chunk.split("\n");
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.type === "user" && parsed.message?.content) {
+              const text =
+                typeof parsed.message.content === "string"
+                  ? parsed.message.content
+                  : "";
+              if (text) {
+                title = truncateTitle(text.split("\n")[0] ?? text);
+                break;
+              }
+            }
+          } catch {
+            // Incomplete JSON line at buffer boundary — skip
+          }
+        }
+
+        const date = formatDate(new Date(stat.mtime));
+        const shortId = sessionId.slice(0, 8);
+
+        entries.push({
+          filename: `${date}-${shortId}.md`,
+          sourcePath: filePath,
+          contentHash: String(stat.size),
+          meta: {
+            title,
+            id: sessionId,
+            source: "claude-code",
+            project: projDir.name,
+            created_at: stat.mtime.toISOString(),
+            updated_at: stat.mtime.toISOString(),
+          },
+        });
+      } catch {
+        // Skip corrupt files
+      }
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Full parse: reads entire JSONL file and generates markdown.
+ */
+export function claudeCodeSessionToMd(jsonlPath: string): string {
+  const text = readFileSync(jsonlPath, "utf-8");
+  const lines = text.split("\n").filter((l: string) => l.trim());
+
+  let title = "";
+  let firstTimestamp = "";
+  let lastTimestamp = "";
+  let sessionId = "";
+  const messages: string[] = [];
+
+  for (const line of lines) {
+    let parsed: any;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (!sessionId && parsed.sessionId) sessionId = parsed.sessionId;
+    if (!firstTimestamp && parsed.timestamp) firstTimestamp = parsed.timestamp;
+    if (parsed.timestamp) lastTimestamp = parsed.timestamp;
+
+    if (parsed.type === "user" && parsed.message) {
+      const text = extractTextFromContent(parsed.message.content);
+      if (!text) continue;
+
+      if (Array.isArray(parsed.message.content)) {
+        const hasToolResult = parsed.message.content.some(
+          (b: ContentBlock) => b.type === "tool_result",
+        );
+        if (hasToolResult) continue;
+      }
+
+      if (!title) title = truncateTitle(text.split("\n")[0] ?? text);
+      messages.push(`## Human\n\n${text}`);
+    } else if (parsed.type === "assistant" && parsed.message) {
+      const text = extractTextFromContent(parsed.message.content);
+      if (text) {
+        messages.push(`## Claude\n\n${text}`);
+      }
+    }
+  }
+
+  if (!title) title = `Session ${sessionId.slice(0, 8)}`;
+
+  const projectDir = basename(dirname(jsonlPath));
+  const meta: SessionMeta = {
+    title,
+    id: sessionId,
+    source: "claude-code",
+    project: projectDir,
+    created_at: firstTimestamp || new Date().toISOString(),
+    updated_at: lastTimestamp || new Date().toISOString(),
+  };
+
+  const frontmatter = buildFrontmatter(meta);
+  return `${frontmatter}\n\n# ${title}\n\n${messages.join("\n\n")}`;
+}

package/src/import/claude-export-to-md.ts

@@ -0,0 +1,122 @@
+import { existsSync, statSync } from "fs";
+import {
+  type SessionEntry,
+  type SessionMeta,
+  buildFrontmatter,
+  formatDate,
+  slugify,
+  truncateTitle,
+} from "./types.ts";
+
+interface ClaudeConversation {
+  uuid: string;
+  name: string;
+  created_at: string;
+  updated_at: string;
+  chat_messages: ChatMessage[];
+}
+
+interface ChatMessage {
+  uuid: string;
+  sender: string;
+  text: string;
+  created_at: string;
+  content?: ContentBlock[];
+}
+
+interface ContentBlock {
+  type: string;
+  text?: string;
+}
+
+function extractText(msg: ChatMessage): string {
+  if (msg.text) return msg.text;
+  if (msg.content) {
+    return msg.content
+      .filter((b) => b.type === "text" && b.text)
+      .map((b) => b.text!)
+      .join("\n\n");
+  }
+  return "";
+}
+
+function conversationToMd(conv: ClaudeConversation): string {
+  const title = conv.name || truncateTitle(conv.chat_messages[0]?.text ?? "Untitled");
+
+  const meta: SessionMeta = {
+    title,
+    id: conv.uuid,
+    source: "claude-export",
+    created_at: conv.created_at,
+    updated_at: conv.updated_at,
+  };
+
+  const messages: string[] = [];
+  for (const msg of conv.chat_messages) {
+    const text = extractText(msg);
+    if (!text) continue;
+
+    const role = msg.sender === "human" ? "Human" : "Claude";
+    messages.push(`## ${role}\n\n${text}`);
+  }
+
+  const frontmatter = buildFrontmatter(meta);
+  return `${frontmatter}\n\n# ${title}\n\n${messages.join("\n\n")}`;
+}
+
+/**
+ * Import Claude.ai export (ZIP or conversations.json).
+ * Returns SessionEntry[] with pre-generated markdown.
+ */
+export async function importClaudeExport(
+  filePath: string,
+): Promise<SessionEntry[]> {
+  if (!existsSync(filePath)) return [];
+
+  let conversations: ClaudeConversation[];
+
+  if (filePath.endsWith(".zip")) {
+    const proc = Bun.spawnSync({
+      cmd: ["unzip", "-p", filePath, "conversations.json"],
+      stdout: "pipe",
+    });
+
+    if (proc.exitCode !== 0) {
+      throw new Error("Failed to extract conversations.json from ZIP");
+    }
+
+    conversations = JSON.parse(new TextDecoder().decode(proc.stdout));
+  } else {
+    const raw = await Bun.file(filePath).text();
+    conversations = JSON.parse(raw);
+  }
+
+  if (!Array.isArray(conversations)) return [];
+
+  const fileHash = String(statSync(filePath).size);
+  const entries: SessionEntry[] = [];
+  for (const conv of conversations) {
+    if (!conv.chat_messages || conv.chat_messages.length === 0) continue;
+
+    const md = conversationToMd(conv);
+    const date = formatDate(new Date(conv.created_at));
+    const slug = slugify(conv.name || "untitled");
+
+    entries.push({
+      filename: `${date}-${slug}.md`,
+      sourcePath: filePath,
+      contentHash: fileHash,
+      md,
+      meta: {
+        title: conv.name || "Untitled",
+        id: conv.uuid,
+        source: "claude-export",
+        created_at: conv.created_at,
+        updated_at: conv.updated_at,
+      },
+    });
+  }
+
+  return entries;
+}
+