@vs4vijay/piverse 0.1.0 → 0.6.0

package/extensions/pi-notes/src/store.ts

@@ -0,0 +1,229 @@
+/**
+ * pi-notes store — load/save/CRUD for notes
+ */
+
+import { promises as fs } from "fs";
+import { join, dirname } from "path";
+import type { Note, NotesState } from "./types.js";
+import { NOTES_DIR, NOTES_FILE } from "./types.js";
+
+export class NoteStore {
+  private cwd: string;
+  private notesPath: string;
+  private cache: Note[] | null = null;
+
+  constructor(cwd: string = process.cwd()) {
+    this.cwd = cwd;
+    this.notesPath = join(cwd, NOTES_DIR, NOTES_FILE);
+  }
+
+  async ensureDir(): Promise<void> {
+    const dir = dirname(this.notesPath);
+    await fs.mkdir(dir, { recursive: true });
+  }
+
+  async load(): Promise<Note[]> {
+    if (this.cache) return this.cache;
+
+    await this.ensureDir();
+
+    try {
+      const data = await fs.readFile(this.notesPath, "utf-8");
+      const parsed = JSON.parse(data) as NotesState;
+      this.cache = parsed.notes ?? [];
+    } catch (err: any) {
+      if (err.code === "ENOENT") {
+        this.cache = [];
+      } else {
+        throw err;
+      }
+    }
+
+    return this.cache;
+  }
+
+  async save(notes: Note[]): Promise<void> {
+    await this.ensureDir();
+
+    const state: NotesState = {
+      notes,
+      version: 1,
+    };
+
+    // Atomic write: write to temp then rename
+    const tempPath = this.notesPath + ".tmp";
+    await fs.writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
+    await fs.rename(tempPath, this.notesPath);
+
+    this.cache = notes;
+  }
+
+  async getAll(): Promise<Note[]> {
+    return this.load();
+  }
+
+  async getById(id: string): Promise<Note | undefined> {
+    const notes = await this.load();
+    return notes.find((n) => n.id === id);
+  }
+
+  async create(title: string, content: string = ""): Promise<Note> {
+    const notes = await this.load();
+    const now = new Date().toISOString();
+
+    const note: Note = {
+      id: crypto.randomUUID(),
+      title,
+      content,
+      createdAt: now,
+      updatedAt: now,
+      tags: [],
+      pinned: false,
+    };
+
+    // Pinned notes first, then by updatedAt desc
+    notes.unshift(note);
+    await this.save(notes);
+
+    return note;
+  }
+
+  async update(id: string, updates: Partial<Pick<Note, "title" | "content" | "tags" | "pinned">>): Promise<Note | undefined> {
+    const notes = await this.load();
+    const index = notes.findIndex((n) => n.id === id);
+
+    if (index === -1) return undefined;
+
+    const updated: Note = {
+      ...notes[index],
+      ...updates,
+      updatedAt: new Date().toISOString(),
+    };
+
+    notes[index] = updated;
+
+    // Re-sort: pinned first, then updatedAt desc
+    notes.sort((a, b) => {
+      if (a.pinned && !b.pinned) return -1;
+      if (!a.pinned && b.pinned) return 1;
+      return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+    });
+
+    await this.save(notes);
+    return updated;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const notes = await this.load();
+    const filtered = notes.filter((n) => n.id !== id);
+
+    if (filtered.length === notes.length) return false;
+
+    await this.save(filtered);
+    return true;
+  }
+
+  async search(query: string): Promise<Note[]> {
+    const notes = await this.load();
+    const lower = query.toLowerCase();
+    return notes.filter(
+      (n) => n.title.toLowerCase().includes(lower) || n.content.toLowerCase().includes(lower)
+    );
+  }
+
+  async exportTo(filePath: string): Promise<number> {
+    const state: NotesState = {
+      notes: await this.getAll(),
+      version: 1,
+    };
+    const dir = dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    const tempPath = filePath + ".tmp";
+    await fs.writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
+    await fs.rename(tempPath, filePath);
+    return state.notes.length;
+  }
+
+  async importFrom(filePath: string): Promise<{ imported: number; skipped: number }> {
+    const data = await fs.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(data) as unknown;
+    const incoming = parseNotesState(parsed);
+
+    const current = await this.getAll();
+    const existingIds = new Set(current.map((n) => n.id));
+    const merged = [...current];
+    let imported = 0;
+
+    for (const note of incoming) {
+      if (existingIds.has(note.id)) continue;
+      merged.push(note);
+      existingIds.add(note.id);
+      imported++;
+    }
+
+    merged.sort((a, b) => {
+      if (a.pinned && !b.pinned) return -1;
+      if (!a.pinned && b.pinned) return 1;
+      return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+    });
+
+    await this.save(merged);
+    return { imported, skipped: incoming.length - imported };
+  }
+}
+
+function parseNotesState(value: unknown): Note[] {
+  if (!value || typeof value !== "object" || !Array.isArray((value as { notes?: unknown }).notes)) {
+    throw new Error('Invalid notes file: expected an object like { "notes": [...] }');
+  }
+  const notes = (value as { notes: unknown[] }).notes;
+  return notes.map((n, i) => parseNote(n, i));
+}
+
+function parseNote(value: unknown, index: number): Note {
+  if (!value || typeof value !== "object") {
+    throw new Error(`Invalid note at index ${index}: expected an object`);
+  }
+  const n = value as Record<string, unknown>;
+  if (
+    typeof n.id !== "string" ||
+    typeof n.title !== "string" ||
+    typeof n.createdAt !== "string" ||
+    typeof n.updatedAt !== "string"
+  ) {
+    throw new Error(`Invalid note at index ${index}: missing id, title, createdAt, or updatedAt`);
+  }
+
+  const note: Note = {
+    id: n.id,
+    title: n.title,
+    content: typeof n.content === "string" ? n.content : "",
+    createdAt: n.createdAt,
+    updatedAt: n.updatedAt,
+  };
+
+  if (Array.isArray(n.tags)) {
+    const tags = n.tags.filter((t): t is string => typeof t === "string");
+    if (tags.length > 0) note.tags = tags;
+  }
+  if (typeof n.pinned === "boolean") note.pinned = n.pinned;
+
+  return note;
+}
+
+// Per-cwd cache so multi-project sessions don't share a single store instance
+const stores = new Map<string, NoteStore>();
+
+export function getNoteStore(cwd?: string): NoteStore {
+  const key = cwd ?? process.cwd();
+  let store = stores.get(key);
+  if (!store) {
+    store = new NoteStore(key);
+    stores.set(key, store);
+  }
+  return store;
+}
+
+export function resetNoteStore(): void {
+  stores.clear();
+}

package/extensions/pi-notes/src/tui.ts

@@ -0,0 +1,426 @@
+/**
+ * pi-notes TUI — interactive note management
+ */
+
+import { VStack, HStack, Box, Text, ScrollView, Markdown, SelectList, type SelectItem, type SelectListTheme, type MarkdownTheme } from "@earendil-works/pi-tui";
+import type { Component, Focusable } from "@earendil-works/pi-tui";
+import { Theme } from "@earendil-works/pi-coding-agent";
+import type { Note } from "./types.js";
+
+interface ListItem {
+  note: Note;
+  display: string;
+}
+
+type ViewMode = "list" | "view" | "editor" | "confirm" | "search";
+
+export class NotesTUI extends VStack implements Focusable {
+  private mode: ViewMode = "list";
+  private notes: Note[] = [];
+  private filteredNotes: ListItem[] = [];
+  private searchQuery = "";
+  private listSelect: SelectList;
+  private previewMarkdown: Markdown;
+  private statusText: Text;
+  private headerText: Text;
+  private theme: Theme;
+  private onClose: () => void;
+  private onExternalEdit: (note?: Note) => Promise<Note[] | undefined>;
+  private onDelete: (id: string) => Promise<Note[]>;
+  private onTogglePin: (note: Note) => Promise<Note[]>;
+  private editingNote: Note | null = null;
+  private confirmAction: "delete" | "cancel" | null = null;
+  private confirmNoteId: string | null = null;
+  private listBox: Box;
+  private previewBox: Box;
+  private headerBox: Box;
+  private statusBox: Box;
+
+  constructor(
+    initialNotes: Note[],
+    theme: Theme,
+    onClose: () => void,
+    onExternalEdit: (note?: Note) => Promise<Note[] | undefined>,
+    onDelete: (id: string) => Promise<Note[]>,
+    onTogglePin: (note: Note) => Promise<Note[]>
+  ) {
+    super([], { gap: 0 });
+    this.theme = theme;
+    this.notes = initialNotes;
+    this.onClose = onClose;
+    this.onExternalEdit = onExternalEdit;
+    this.onDelete = onDelete;
+    this.onTogglePin = onTogglePin;
+    this.filteredNotes = this.buildListItems(this.notes);
+
+    // Header
+    this.headerText = new Text("Pi Notes  [n] new  [/] search  [q] quit");
+    this.headerBox = new Box(1, 0);
+    this.headerBox.addChild(this.headerText);
+
+    // Status line
+    this.statusText = new Text(this.buildStatusText());
+    this.statusBox = new Box(1, 0);
+    this.statusBox.addChild(this.statusText);
+
+    // List selector - use SelectItem type from pi-tui
+    const selectItems: SelectItem[] = this.filteredNotes.map(item => ({
+      value: item.note.id,
+      label: item.display,
+    }));
+
+    this.listSelect = new SelectList(selectItems, 20, this.getSelectTheme());
+
+    // Preview markdown
+    this.previewMarkdown = new Markdown("", 0, 0, this.getMarkdownTheme(theme));
+
+    // Layout: Header | List (left) + Preview (right) | Status
+    const listScrollView = new ScrollView(this.listSelect, { scrollbar: "auto" });
+    this.listBox = new Box(0, 0);
+    this.listBox.addChild(listScrollView);
+
+    const previewScrollView = new ScrollView(this.previewMarkdown, { scrollbar: "auto" });
+    this.previewBox = new Box(0, 0);
+    this.previewBox.addChild(previewScrollView);
+
+    const mainSplit = new HStack([this.listBox, this.previewBox], { gap: 1 });
+
+    this.addChild(this.headerBox);
+    this.addChild(mainSplit);
+    this.addChild(this.statusBox);
+
+    // Listen for selection changes
+    this.listSelect.onSelectionChange = (item) => this.onListSelect(item);
+    this.updatePreview();
+  }
+
+  private getSelectTheme(): SelectListTheme {
+    return {
+      selectedPrefix: (text) => `\x1b[7m ${text} \x1b[0m`,
+      selectedText: (text) => `\x1b[7m${text}\x1b[0m`,
+      description: (text) => `\x1b[90m${text}\x1b[0m`,
+      scrollInfo: (text) => `\x1b[90m${text}\x1b[0m`,
+      noMatch: (text) => `\x1b[31m${text}\x1b[0m`,
+    };
+  }
+
+  private getMarkdownTheme(theme: Theme): MarkdownTheme {
+    const fg = (color: string) => (text: string) => theme.fg(color as any, text);
+    return {
+      heading: fg("accent"),
+      link: fg("accent"),
+      linkUrl: fg("accent"),
+      code: fg("foreground"),
+      codeBlock: fg("foreground"),
+      codeBlockBorder: fg("border"),
+      quote: fg("muted"),
+      quoteBorder: fg("border"),
+      hr: fg("border"),
+      listBullet: fg("muted"),
+      bold: (text) => `\x1b[1m${text}\x1b[0m`,
+      italic: (text) => `\x1b[3m${text}\x1b[0m`,
+      strikethrough: (text) => `\x1b[9m${text}\x1b[0m`,
+      underline: (text) => `\x1b[4m${text}\x1b[0m`,
+    };
+  }
+
+  private buildListItems(notes: Note[]): ListItem[] {
+    return notes.map((note) => {
+      const preview = note.content.slice(0, 60).replace(/\n/g, " ");
+      const pin = note.pinned ? "📌 " : "";
+      const tags = note.tags?.length ? ` [${note.tags.join(", ")}]` : "";
+      return {
+        note,
+        display: `${pin}${note.title}${tags}\n  ${preview}`,
+      };
+    });
+  }
+
+  private buildStatusText(): string {
+    const total = this.notes.length;
+    const filtered = this.filteredNotes.length;
+    const pinned = this.notes.filter((n) => n.pinned).length;
+    const mode = this.mode === "list" ? "LIST" : this.mode.toUpperCase();
+    const search = this.searchQuery ? ` | search: "${this.searchQuery}"` : "";
+    return `${mode} | ${filtered}/${total} notes${pinned ? ` | ${pinned} pinned` : ""}${search}`;
+  }
+
+  private onListSelect(item: SelectItem | undefined): void {
+    if (item) {
+      const note = this.filteredNotes.find(n => n.note.id === item.value)?.note;
+      if (note) this.updatePreview(note);
+    }
+  }
+
+  private updatePreview(note?: Note): void {
+    const target = note ?? this.getSelectedNote();
+    if (target) {
+      this.previewMarkdown.setText(target.content || "*(empty)*");
+    } else {
+      this.previewMarkdown.setText("*(no notes)*");
+    }
+  }
+
+  private getSelectedNote(): Note | null {
+    const selected = this.listSelect.getSelectedItem();
+    if (!selected) return null;
+    return this.filteredNotes.find(n => n.note.id === selected.value)?.note ?? null;
+  }
+
+  private refreshList(): void {
+    this.filteredNotes = this.buildListItems(this.applyFilter(this.notes));
+    const selectItems: SelectItem[] = this.filteredNotes.map(item => ({
+      value: item.note.id,
+      label: item.display,
+    }));
+    // Replace SelectList - need to recreate the list
+    this.listSelect = new SelectList(selectItems, 20, this.getSelectTheme());
+    // Update list box child
+    this.listBox.clear();
+    this.listBox.addChild(new ScrollView(this.listSelect, { scrollbar: "auto" }));
+    this.listSelect.onSelectionChange = (item) => this.onListSelect(item);
+    this.statusText.setText(this.buildStatusText());
+    this.updatePreview();
+  }
+
+  private applyFilter(notes: Note[]): Note[] {
+    if (!this.searchQuery) return notes;
+    const q = this.searchQuery.toLowerCase();
+    return notes.filter(
+      (n) => n.title.toLowerCase().includes(q) || n.content.toLowerCase().includes(q)
+    );
+  }
+
+  // Focusable implementation
+  private _focused = false;
+
+  set focused(value: boolean) {
+    this._focused = value;
+    // SelectList doesn't have focused property
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  handleInput(keyData: string): void {
+    if (this.mode === "search") {
+      this.handleSearchInput(keyData);
+      return;
+    }
+
+    // Global keys
+    if (keyData === "q" || keyData === "Escape") {
+      if (this.mode === "list") {
+        this.onClose();
+        return;
+      }
+      this.exitMode();
+      return;
+    }
+
+    // Mode-specific handling
+    switch (this.mode) {
+      case "list":
+        this.handleListInput(keyData);
+        break;
+      case "view":
+        this.handleViewInput(keyData);
+        break;
+      case "confirm":
+        this.handleConfirmInput(keyData);
+        break;
+    }
+  }
+
+  private handleListInput(key: string): void {
+    switch (key) {
+      case "n":
+        this.openEditor();
+        break;
+      case "e":
+        this.editSelected();
+        break;
+      case "d":
+        this.confirmDelete();
+        break;
+      case "p":
+        this.togglePin();
+        break;
+      case "/":
+        this.startSearch();
+        break;
+      case "Enter":
+        this.enterViewMode();
+        break;
+      case "ArrowUp":
+      case "k":
+        this.listSelect.handleInput("ArrowUp");
+        break;
+      case "ArrowDown":
+      case "j":
+        this.listSelect.handleInput("ArrowDown");
+        break;
+      case "PageUp":
+        this.listSelect.handleInput("PageUp");
+        break;
+      case "PageDown":
+        this.listSelect.handleInput("PageDown");
+        break;
+      case "Home":
+        this.listSelect.handleInput("Home");
+        break;
+      case "End":
+        this.listSelect.handleInput("End");
+        break;
+    }
+  }
+
+  private handleViewInput(key: string): void {
+    switch (key) {
+      case "e":
+        this.editSelected();
+        this.exitMode();
+        break;
+      case "q":
+      case "Escape":
+        this.exitMode();
+        break;
+    }
+  }
+
+  private handleConfirmInput(key: string): void {
+    if (key === "y" || key === "Y") {
+      if (this.confirmAction === "delete" && this.confirmNoteId) {
+        const id = this.confirmNoteId;
+        this.onDelete(id).then((notes) => {
+          this.notes = notes;
+          this.refreshList();
+        });
+      }
+      this.exitConfirmMode();
+    } else if (key === "n" || key === "N" || key === "Escape") {
+      this.exitConfirmMode();
+    }
+  }
+
+  private handleSearchInput(key: string): void {
+    if (key === "Escape" || key === "Enter") {
+      this.endSearch();
+      return;
+    }
+    if (key === "Backspace" || key === "backspace") {
+      this.searchQuery = this.searchQuery.slice(0, -1);
+    } else if (!isPrintableSearchChar(key)) {
+      return;
+    } else {
+      this.searchQuery += key;
+    }
+    this.updateSearchHeader();
+    this.statusText.setText(this.buildStatusText());
+    this.refreshList();
+  }
+
+  private enterViewMode(): void {
+    const note = this.getSelectedNote();
+    if (note) {
+      this.mode = "view";
+      this.headerText.setText(`Pi Notes — ${note.title}  [e] edit  [q] back`);
+      this.statusText.setText(this.buildStatusText());
+    }
+  }
+
+  private exitMode(): void {
+    this.mode = "list";
+    this.headerText.setText("Pi Notes  [n] new  [/] search  [q] quit");
+    this.statusText.setText(this.buildStatusText());
+  }
+
+  private exitConfirmMode(): void {
+    this.mode = "list";
+    this.confirmAction = null;
+    this.confirmNoteId = null;
+    this.headerText.setText("Pi Notes  [n] new  [/] search  [q] quit");
+    this.statusText.setText(this.buildStatusText());
+  }
+
+  private startSearch(): void {
+    this.mode = "search";
+    this.updateSearchHeader();
+    this.statusText.setText(this.buildStatusText());
+  }
+
+  private endSearch(): void {
+    this.mode = "list";
+    this.headerText.setText("Pi Notes  [n] new  [/] search  [q] quit");
+    this.statusText.setText(this.buildStatusText());
+  }
+
+  private updateSearchHeader(): void {
+    this.headerText.setText(`Pi Notes — Search: ${this.searchQuery || ""}  [Esc] done`);
+  }
+
+  private openEditor(note?: Note): void {
+    this.mode = "editor";
+    this.editingNote = note ?? null;
+    this.headerText.setText(note ? `Pi Notes — Edit: ${note.title}  [Esc] cancel` : "Pi Notes — New Note  [Esc] cancel");
+    this.statusText.setText("Editing... use external editor");
+    this.requestExternalEdit(note);
+  }
+
+  private editSelected(): void {
+    const note = this.getSelectedNote();
+    if (note) {
+      this.openEditor(note);
+    }
+  }
+
+  private confirmDelete(): void {
+    const note = this.getSelectedNote();
+    if (note) {
+      this.mode = "confirm";
+      this.confirmAction = "delete";
+      this.confirmNoteId = note.id;
+      this.headerText.setText(`Delete "${note.title}"?  [y] yes  [n] no`);
+      this.statusText.setText("Confirm deletion");
+    }
+  }
+
+  private togglePin(): void {
+    const note = this.getSelectedNote();
+    if (note) {
+      this.onTogglePin(note).then((notes) => {
+        this.notes = notes;
+        this.refreshList();
+      });
+    }
+  }
+
+  private async requestExternalEdit(note?: Note): Promise<void> {
+    const updated = await this.onExternalEdit(note);
+    this.editingNote = null;
+    if (updated) {
+      this.notes = updated;
+      this.refreshList();
+    }
+    this.exitMode();
+  }
+}
+
+function isPrintableSearchChar(key: string): boolean {
+  if (key.length !== 1) return false;
+  const code = key.charCodeAt(0);
+  return code >= 32 && code !== 127;
+}
+
+// Factory function for ctx.ui.custom()
+export function createNotesTUI(
+  notes: Note[],
+  theme: Theme,
+  onClose: () => void,
+  onExternalEdit: (note?: Note) => Promise<Note[] | undefined>,
+  onDelete: (id: string) => Promise<Note[]>,
+  onTogglePin: (note: Note) => Promise<Note[]>
+): Component & Focusable {
+  return new NotesTUI(notes, theme, onClose, onExternalEdit, onDelete, onTogglePin);
+}

package/extensions/pi-notes/src/types.ts

@@ -0,0 +1,60 @@
+/**
+ * pi-notes type definitions
+ */
+
+export interface Note {
+  id: string;
+  title: string;
+  content: string;
+  createdAt: string; // ISO 8601
+  updatedAt: string; // ISO 8601
+  tags?: string[];
+  pinned?: boolean;
+}
+
+export interface NotesState {
+  notes: Note[];
+  version: number; // for future migrations
+}
+
+export type Subcommand = "list" | "show" | "rm" | "edit" | "search" | "tag" | "untag" | "pin" | "unpin" | "export" | "import" | "";
+
+export interface ParsedCommand {
+  subcommand: Subcommand;
+  args: string[]; // remaining arguments after subcommand
+}
+
+export function parseNotesCommand(input: string): ParsedCommand {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { subcommand: "", args: [] };
+  }
+
+  const parts = trimmed.split(/\s+/);
+  const first = parts[0];
+
+  const subcommands: Subcommand[] = [
+    "list",
+    "show",
+    "rm",
+    "edit",
+    "search",
+    "tag",
+    "untag",
+    "pin",
+    "unpin",
+    "export",
+    "import",
+  ];
+
+  if (subcommands.includes(first as Subcommand)) {
+    return { subcommand: first as Subcommand, args: parts.slice(1) };
+  }
+
+  // No recognized subcommand — treat entire input as title for quick-add
+  return { subcommand: "", args: [trimmed] };
+}
+
+export const NOTES_DIR = ".pi/notes";
+export const NOTES_FILE = "notes.json";
+export const TEMPLATES_DIR = "templates";