@hutusi/amytis 1.7.0 → 1.9.0

package/scripts/import-book.ts

@@ -0,0 +1,176 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+
+// Usage: bun run scripts/import-book.ts <main-file-path>
+// Example: bun run scripts/import-book.ts imports/books/agentic-design-patterns/chapters/Agentic\ Design\ Patterns.md
+
+const args = process.argv.slice(2);
+const mainFilePath = args[0];
+
+if (!mainFilePath) {
+  console.error('Usage: bun run scripts/import-book.ts <main-file-path>');
+  process.exit(1);
+}
+
+const fullMainPath = path.isAbsolute(mainFilePath) ? mainFilePath : path.join(process.cwd(), mainFilePath);
+
+if (!fs.existsSync(fullMainPath)) {
+  console.error(`Error: Main file not found at ${fullMainPath}`);
+  process.exit(1);
+}
+
+const sourceDir = path.dirname(fullMainPath);
+// Parent of chapters/ is usually the book root
+const bookRootDir = path.dirname(sourceDir); 
+const bookSlug = path.basename(bookRootDir).toLowerCase().replace(/[^a-z0-9]+/g, '-');
+const contentDir = path.join(process.cwd(), 'content', 'books', bookSlug);
+
+if (!fs.existsSync(contentDir)) {
+  fs.mkdirSync(contentDir, { recursive: true });
+}
+
+const mainContent = fs.readFileSync(fullMainPath, 'utf8');
+const lines = mainContent.split('\n');
+
+interface ChapterRef { title: string; id: string }
+interface PartGroup { part: string; chapters: ChapterRef[] }
+type TocItem = ChapterRef | PartGroup;
+
+const toc: TocItem[] = [];
+let currentPart: PartGroup | null = null;
+const usedChapterIds = new Set<string>();
+
+function slugify(text: string): string {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
+      .replace(/(^-|-$)+/g, '');
+}
+
+function processChapter(title: string, rawPath: string): ChapterRef | null {
+    // Decode URI component (e.g. %20 -> space)
+    const cleanPath = decodeURIComponent(rawPath.replace(/^<|>$/g, ''));
+    const fullSrcPath = path.resolve(sourceDir, cleanPath);
+    const relativeToRoot = path.relative(bookRootDir, fullSrcPath);
+    if (relativeToRoot.startsWith('..') || path.isAbsolute(relativeToRoot)) {
+        console.warn(`Warning: Chapter path escapes book root, skipping: ${rawPath}`);
+        return null;
+    }
+    
+    if (!fs.existsSync(fullSrcPath)) {
+        console.warn(`Warning: File not found: ${fullSrcPath}`);
+        return null;
+    }
+
+    let id = slugify(path.basename(cleanPath).replace(/\.mdx?$/, ''));
+    if (!id) {
+        id = slugify(title);
+    }
+    if (!id) {
+        console.warn(`Warning: Could not derive chapter id, skipping: ${rawPath}`);
+        return null;
+    }
+    const baseId = id;
+    let suffix = 2;
+    while (usedChapterIds.has(id) || fs.existsSync(path.join(contentDir, `${id}.mdx`))) {
+        id = `${baseId}-${suffix++}`;
+    }
+    usedChapterIds.add(id);
+    const destPath = path.join(contentDir, `${id}.mdx`);
+
+    const rawContent = fs.readFileSync(fullSrcPath, 'utf8');
+    const { data, content: body } = matter(rawContent);
+
+    let finalTitle = data.title;
+    if (!finalTitle) {
+        const h1Match = body.match(/^#\s+(.*)/m);
+        if (h1Match) {
+            finalTitle = h1Match[1].trim();
+        }
+    }
+    if (!finalTitle) finalTitle = title;
+
+    const chapterData = {
+        ...data,
+        title: finalTitle,
+    };
+
+    let fixedBody = body;
+    
+    // Normalize image paths to ./images/ regardless of source prefix (../images/, ./images/, images/)
+    fixedBody = fixedBody.replace(/(?:\.\.\/|\.\/)?images\//g, './images/');
+
+    fs.writeFileSync(destPath, matter.stringify(fixedBody, chapterData));
+    return { title: chapterData.title, id };
+}
+
+for (const line of lines) {
+    // Detect Parts (H2)
+    const partMatch = line.match(/^##\s+(.*)/);
+    if (partMatch) {
+        currentPart = { part: partMatch[1].trim(), chapters: [] };
+        toc.push(currentPart);
+        continue;
+    }
+
+    // Detect Chapter links in list items
+    // Matches: - [Title](Path) or 1. [Title](Path)
+    const chapterMatch = line.match(/^[-*\d.]+\s+\[(.*?)\]\((.*)\)/);
+    if (chapterMatch) {
+        const title = chapterMatch[1];
+        const rawPath = chapterMatch[2];
+        const ch = processChapter(title, rawPath);
+        
+        if (ch) {
+            if (currentPart) {
+                currentPart.chapters.push(ch);
+            } else {
+                toc.push(ch);
+            }
+        }
+    }
+}
+
+// Write index.mdx
+// Use the H1 from the main file as title
+const h1Match = mainContent.match(/^#\s+(.*)/);
+const bookTitle = h1Match ? h1Match[1].trim() : bookSlug.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+
+const indexData = {
+  title: bookTitle,
+  date: new Date().toISOString().split('T')[0],
+  excerpt: `Imported book: ${bookTitle}`,
+  chapters: toc,
+  draft: false,
+};
+
+// Also copy the main file content as the introduction/landing page content
+const { content: introBody } = matter(mainContent);
+let fixedIntroBody = introBody;
+fixedIntroBody = fixedIntroBody.replace(/\.\.\/images\//g, './images/');
+
+fs.writeFileSync(path.join(contentDir, 'index.mdx'), matter.stringify(fixedIntroBody, indexData));
+
+// Copy images from bookRootDir/images to contentDir/images
+const srcImages = path.join(bookRootDir, 'images');
+const destImages = path.join(contentDir, 'images');
+if (fs.existsSync(srcImages)) {
+    if (!fs.existsSync(destImages)) fs.mkdirSync(destImages, { recursive: true });
+    const copyDir = (src: string, dest: string) => {
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const sPath = path.join(src, entry.name);
+            const dPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                if (!fs.existsSync(dPath)) fs.mkdirSync(dPath, { recursive: true });
+                copyDir(sPath, dPath);
+            } else {
+                fs.copyFileSync(sPath, dPath);
+            }
+        }
+    };
+    copyDir(srcImages, destImages);
+}
+
+console.log(`Successfully imported book to ${contentDir}`);

package/scripts/new-flow-from-chat.ts

@@ -0,0 +1,238 @@
+import fs from 'fs';
+import path from 'path';
+
+// Usage (auto-scan — recommended):
+//   bun run new-flow-from-chat                         # import all new files in imports/chats/
+//   bun run new-flow-from-chat --all                   # re-import every file (ignore history)
+//   bun run new-flow-from-chat --dry-run               # preview without writing
+//   bun run new-flow-from-chat --author "Alice"        # only include Alice's messages
+//   bun run new-flow-from-chat --append                # append to existing flow files
+//   bun run new-flow-from-chat --timestamp             # include timestamps (default: excluded)
+//
+// Usage (explicit file):
+//   bun run new-flow-from-chat <file>                  # process one specific file
+//
+// Import history is tracked in imports/chats/.imported (one filename per line).
+// That file is gitignored along with the rest of imports/.
+//
+// Input format (one message block per entry):
+//   username YYYY-MM-DD HH:mm:ss
+//   message line 1
+//   message line 2
+//   ...
+//
+// Output: content/flows/YYYY/MM/DD.md  (one file per calendar day)
+
+const CHATS_DIR = path.join(process.cwd(), 'imports', 'chats');
+const IMPORTED_RECORD = path.join(CHATS_DIR, '.imported');
+
+// ── Arg parsing ────────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+
+// Collect positional args, skipping values that follow named flags
+const positional: string[] = [];
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--author') { i++; continue; }
+  if (!args[i].startsWith('--')) positional.push(args[i]);
+}
+
+const explicitFile      = positional[0] ?? null;
+const authorIdx         = args.indexOf('--author');
+const filterAuthor      = authorIdx > -1 ? args[authorIdx + 1] : null;
+const dryRun            = args.includes('--dry-run');
+const appendMode        = args.includes('--append');
+const reimportAll       = args.includes('--all');
+const includeTimestamp  = args.includes('--timestamp');
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+interface Message {
+  username: string;
+  date: string;   // YYYY-MM-DD
+  time: string;   // HH:mm:ss
+  lines: string[];
+}
+
+// ── Parser ─────────────────────────────────────────────────────────────────
+
+// Matches: "username YYYY-MM-DD HH:mm:ss" (username may contain spaces)
+const HEADER_RE = /^(.+?)\s+(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2})$/;
+
+function parseChat(raw: string): Message[] {
+  const messages: Message[] = [];
+  let current: Message | null = null;
+
+  for (const rawLine of raw.split('\n')) {
+    const line = rawLine.replace(/\r$/, ''); // strip Windows line endings
+    const match = line.match(HEADER_RE);
+    if (match) {
+      if (current) messages.push(current);
+      current = { username: match[1].trim(), date: match[2], time: match[3], lines: [] };
+    } else if (current) {
+      current.lines.push(line);
+    }
+    // Lines before the first header are silently ignored
+  }
+
+  if (current) messages.push(current);
+  return messages;
+}
+
+// ── Rendering ─────────────────────────────────────────────────────────────
+
+function renderBlock(msg: Message, showUsername: boolean, showTime: boolean): string {
+  const content = msg.lines.join('\n').trimEnd();
+  if (!content.trim()) return ''; // skip empty messages
+
+  const headerParts: string[] = [];
+  if (showUsername) headerParts.push(`**${msg.username}**`);
+  if (showTime) headerParts.push(msg.time);
+
+  if (headerParts.length === 0) return content;
+  return `${headerParts.join(' · ')}\n\n${content}`;
+}
+
+function renderFlow(messages: Message[], showUsername: boolean, showTime: boolean): string {
+  const blocks = messages.map(m => renderBlock(m, showUsername, showTime)).filter(Boolean);
+  return `---\ntags: []\n---\n\n${blocks.join('\n\n---\n\n')}\n`;
+}
+
+// ── Import tracking ────────────────────────────────────────────────────────
+
+function loadImported(): Set<string> {
+  if (!fs.existsSync(IMPORTED_RECORD)) return new Set();
+  return new Set(
+    fs.readFileSync(IMPORTED_RECORD, 'utf8')
+      .split('\n').map(l => l.trim()).filter(Boolean),
+  );
+}
+
+function markImported(filename: string): void {
+  fs.appendFileSync(IMPORTED_RECORD, filename + '\n');
+}
+
+// ── File discovery ─────────────────────────────────────────────────────────
+
+function findPendingFiles(): string[] {
+  if (!fs.existsSync(CHATS_DIR)) {
+    console.error(`Directory not found: ${CHATS_DIR}`);
+    console.error('Create it (or run: mkdir -p imports/chats) and drop chat export files there.');
+    process.exit(1);
+  }
+  const imported = reimportAll ? new Set<string>() : loadImported();
+  return fs.readdirSync(CHATS_DIR)
+    .filter(name => !name.startsWith('.') && /\.(txt|log)$/i.test(name))
+    .filter(name => !imported.has(name))
+    .sort()
+    .map(name => path.join(CHATS_DIR, name));
+}
+
+// ── Process one file ───────────────────────────────────────────────────────
+
+function processFile(filePath: string): boolean {
+  const raw = fs.readFileSync(filePath, 'utf8');
+  const allMessages = parseChat(raw);
+
+  if (allMessages.length === 0) {
+    console.log(`  ⚠  no messages found — check the file format`);
+    return false;
+  }
+
+  const messages = filterAuthor
+    ? allMessages.filter(m => m.username.toLowerCase() === filterAuthor.toLowerCase())
+    : allMessages;
+
+  if (messages.length === 0) {
+    console.log(`  ⚠  no messages from "${filterAuthor}" found`);
+    return false;
+  }
+
+  const byDate = new Map<string, Message[]>();
+  for (const msg of messages) {
+    const list = byDate.get(msg.date) ?? [];
+    list.push(msg);
+    byDate.set(msg.date, list);
+  }
+
+  const showUsername = filterAuthor === null;
+  const showTime = includeTimestamp;
+  const flowsDir = path.join(process.cwd(), 'content', 'flows');
+  let created = 0, appended = 0, skipped = 0;
+
+  for (const [date, dayMsgs] of [...byDate.entries()].sort()) {
+    const [year, month, day] = date.split('-');
+    const dirPath = path.join(flowsDir, year, month);
+    const mdPath  = path.join(dirPath, `${day}.md`);
+    const mdxPath = path.join(dirPath, `${day}.mdx`);
+    const existing = fs.existsSync(mdPath) ? mdPath : fs.existsSync(mdxPath) ? mdxPath : null;
+    const flowContent = renderFlow(dayMsgs, showUsername, showTime);
+
+    if (dryRun) {
+      const label = `${date} (${dayMsgs.length} msg${dayMsgs.length === 1 ? '' : 's'})`;
+      console.log(`    ── ${label} → ${path.relative(process.cwd(), mdPath)}`);
+      console.log(flowContent);
+      continue;
+    }
+
+    if (existing && !appendMode) {
+      console.log(`    ⚠  ${date}: flow already exists — skipped (use --append to add)`);
+      skipped++;
+      continue;
+    }
+
+    if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+
+    if (existing) {
+      const blocks = flowContent.replace(/^---[\s\S]*?---\n\n/, '').trimEnd();
+      fs.appendFileSync(existing, `\n\n---\n\n${blocks}\n`);
+      console.log(`    +  ${date}: appended ${dayMsgs.length} msg${dayMsgs.length === 1 ? '' : 's'} → ${path.basename(existing)}`);
+      appended++;
+    } else {
+      fs.writeFileSync(mdPath, flowContent);
+      console.log(`    ✓  ${date}: ${path.relative(process.cwd(), mdPath)} (${dayMsgs.length} msg${dayMsgs.length === 1 ? '' : 's'})`);
+      created++;
+    }
+  }
+
+  const parts: string[] = [];
+  if (created  > 0) parts.push(`${created} created`);
+  if (appended > 0) parts.push(`${appended} appended`);
+  if (skipped  > 0) parts.push(`${skipped} skipped`);
+  const summary = dryRun ? 'dry run' : (parts.join(', ') || 'nothing to do');
+  console.log(`    → ${summary} · ${messages.length} msg${messages.length === 1 ? '' : 's'} across ${byDate.size} day${byDate.size === 1 ? '' : 's'}`);
+
+  return true;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+if (explicitFile) {
+  if (!fs.existsSync(explicitFile)) {
+    console.error(`Error: "${explicitFile}" not found.`);
+    process.exit(1);
+  }
+  console.log(`Processing: ${explicitFile}${dryRun ? ' (dry run)' : ''}`);
+  processFile(explicitFile);
+} else {
+  const pending = findPendingFiles();
+
+  if (pending.length === 0) {
+    const hint = reimportAll ? '' : ' (run with --all to re-import everything)';
+    console.log(`Nothing new to import in imports/chats/${hint}.`);
+    process.exit(0);
+  }
+
+  const modeLabel = dryRun ? ' (dry run)' : reimportAll ? ' (--all)' : '';
+  console.log(`Found ${pending.length} file${pending.length === 1 ? '' : 's'} to import${modeLabel}:`);
+
+  for (const filePath of pending) {
+    console.log(`\n  ${path.basename(filePath)}`);
+    const ok = processFile(filePath);
+    if (!dryRun && ok) markImported(path.basename(filePath));
+  }
+
+  if (!dryRun) {
+    console.log(`\nDone. Import history saved to ${path.relative(process.cwd(), IMPORTED_RECORD)}.`);
+  }
+}

package/scripts/new-flow.ts

@@ -2,14 +2,12 @@ import fs from 'fs';
 import path from 'path';
 
 const args = process.argv.slice(2);
-const title = args.filter(arg => !arg.startsWith('--'))[0];
 const useMdx = args.includes('--mdx');
 
 const now = new Date();
 const year = String(now.getFullYear());
 const month = String(now.getMonth() + 1).padStart(2, '0');
 const day = String(now.getDate()).padStart(2, '0');
-const dateStr = `${year}-${month}-${day}`;
 
 const ext = useMdx ? '.mdx' : '.md';
 const dirPath = path.join(process.cwd(), 'content', 'flows', year, month);
@@ -34,10 +32,7 @@ if (!fs.existsSync(dirPath)) {
   fs.mkdirSync(dirPath, { recursive: true });
 }
 
-const flowTitle = title || dateStr;
-
 const content = `---
-title: "${flowTitle}"
 tags: []
 ---
 

package/scripts/new-note.ts

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+
+const args = process.argv.slice(2);
+const titleArg = args.filter(arg => !arg.startsWith('--'))[0];
+const useMd = args.includes('--md');
+
+if (!titleArg) {
+  console.error('Usage: bun run new-note "Note Title"');
+  process.exit(1);
+}
+
+// Slugify title
+const slug = titleArg
+  .toLowerCase()
+  .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
+  .replace(/^-|-$/g, '');
+
+const now = new Date();
+const dateStr = now.toISOString().split('T')[0];
+const ext = useMd ? '.md' : '.mdx';
+
+const notesDir = path.join(process.cwd(), 'content', 'notes');
+const targetPath = path.join(notesDir, `${slug}${ext}`);
+
+const altExt = useMd ? '.mdx' : '.md';
+const altPath = path.join(notesDir, `${slug}${altExt}`);
+
+if (fs.existsSync(targetPath)) {
+  console.error(`Error: Note already exists at ${targetPath}`);
+  process.exit(1);
+}
+
+if (fs.existsSync(altPath)) {
+  console.error(`Error: Note already exists at ${altPath}`);
+  process.exit(1);
+}
+
+if (!fs.existsSync(notesDir)) {
+  fs.mkdirSync(notesDir, { recursive: true });
+}
+
+const content = `---
+title: "${titleArg}"
+date: "${dateStr}"
+tags: []
+aliases: []
+---
+
+`;
+
+fs.writeFileSync(targetPath, content);
+console.log(`Created new note: ${targetPath}`);