@gmickel/gno 0.34.1 → 0.36.0

package/README.md

@@ -427,11 +427,14 @@ Open `http://localhost:3000` to:
 - **Search**: BM25, vector, or hybrid modes with visual results
 - **Browse**: Cross-collection tree workspace with folder detail panes and per-tab browse context
 - **Edit**: Create, edit, and delete documents with live preview
+- **Create in place**: New notes in the current folder/collection with presets and command-palette flows
 - **Ask**: AI-powered Q&A with citations
 - **Manage Collections**: Add, remove, and re-index collections
 - **Connect agents**: Install core Skill/MCP integrations from the app
 - **Manage files safely**: Rename, reveal, or move editable files to Trash with explicit index-vs-disk semantics
+- **Refactor files safely**: Move, duplicate, and organize editable notes with reference warnings
 - **Switch presets**: Change models live without restart
+- **Command palette**: Jump, create, refactor, and section-navigate from one keyboard-first surface
 
 ### Search
 
@@ -445,19 +448,20 @@ Three retrieval modes: BM25 (keyword), Vector (semantic), or Hybrid (best of bot
 
 Full-featured markdown editor with:
 
-| Feature                 | Description                          |
-| :---------------------- | :----------------------------------- |
-| **Split View**          | Side-by-side editor and live preview |
-| **Auto-save**           | 2-second debounced saves             |
-| **Syntax Highlighting** | CodeMirror 6 with markdown support   |
-| **Keyboard Shortcuts**  | ⌘S save, ⌘B bold, ⌘I italic, ⌘K link |
-| **Quick Capture**       | ⌘N creates new note from anywhere    |
+| Feature                 | Description                                  |
+| :---------------------- | :------------------------------------------- |
+| **Split View**          | Side-by-side editor and live preview         |
+| **Auto-save**           | 2-second debounced saves                     |
+| **Syntax Highlighting** | CodeMirror 6 with markdown support           |
+| **Keyboard Shortcuts**  | ⌘S save, ⌘B bold, ⌘I italic, ⌘K link         |
+| **Quick Capture**       | ⌘N creates new note from anywhere            |
+| **Presets**             | Structured note scaffolds and insert actions |
 
 ### Document Viewer
 
 ![GNO Document Viewer](./assets/screenshots/webui-doc-view.jpg)
 
-View documents with full context: outgoing links, backlinks, and AI-powered related notes sidebar.
+View documents with full context: outgoing links, backlinks, section outline, and AI-powered related notes sidebar.
 
 ### Browse Workspace
 
@@ -467,6 +471,7 @@ Navigate your notes like a real workspace, not just a flat list:
 
 - Cross-collection tree sidebar
 - Folder detail panes
+- Create note and create folder from current browse context
 - Pinned collections and per-tab browse state
 - Direct jump from folder structure into notes
 
@@ -516,24 +521,30 @@ curl -X POST http://localhost:3000/api/ask \
 curl http://localhost:3000/api/status
 ```
 
-| Endpoint                   | Method | Description                 |
-| :------------------------- | :----- | :-------------------------- |
-| `/api/query`               | POST   | Hybrid search (recommended) |
-| `/api/search`              | POST   | BM25 keyword search         |
-| `/api/ask`                 | POST   | AI-powered Q&A              |
-| `/api/docs`                | GET    | List documents              |
-| `/api/docs`                | POST   | Create document             |
-| `/api/docs/:id`            | PUT    | Update document content     |
-| `/api/docs/:id/deactivate` | POST   | Remove from index           |
-| `/api/doc`                 | GET    | Get document content        |
-| `/api/collections`         | POST   | Add collection              |
-| `/api/collections/:name`   | DELETE | Remove collection           |
-| `/api/sync`                | POST   | Trigger re-index            |
-| `/api/status`              | GET    | Index statistics            |
-| `/api/presets`             | GET    | List model presets          |
-| `/api/presets`             | POST   | Switch preset               |
-| `/api/models/pull`         | POST   | Download models             |
-| `/api/models/status`       | GET    | Download progress           |
+| Endpoint                      | Method | Description                 |
+| :---------------------------- | :----- | :-------------------------- |
+| `/api/query`                  | POST   | Hybrid search (recommended) |
+| `/api/search`                 | POST   | BM25 keyword search         |
+| `/api/ask`                    | POST   | AI-powered Q&A              |
+| `/api/docs`                   | GET    | List documents              |
+| `/api/docs`                   | POST   | Create document             |
+| `/api/docs/:id`               | PUT    | Update document content     |
+| `/api/docs/:id/move`          | POST   | Move editable document      |
+| `/api/docs/:id/duplicate`     | POST   | Duplicate editable document |
+| `/api/docs/:id/refactor-plan` | POST   | Preview file-op warnings    |
+| `/api/docs/:id/deactivate`    | POST   | Remove from index           |
+| `/api/doc`                    | GET    | Get document content        |
+| `/api/doc/:id/sections`       | GET    | Get document sections       |
+| `/api/collections`            | POST   | Add collection              |
+| `/api/collections/:name`      | DELETE | Remove collection           |
+| `/api/folders`                | POST   | Create folder               |
+| `/api/sync`                   | POST   | Trigger re-index            |
+| `/api/status`                 | GET    | Index statistics            |
+| `/api/note-presets`           | GET    | List note presets           |
+| `/api/presets`                | GET    | List model presets          |
+| `/api/presets`                | POST   | Switch preset               |
+| `/api/models/pull`            | POST   | Download models             |
+| `/api/models/status`          | GET    | Download progress           |
 
 No authentication. No rate limits. Build custom tools, automate workflows, integrate with any language.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "0.34.1",
+  "version": "0.36.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/core/file-ops.ts

@@ -5,7 +5,7 @@
  */
 
 // node:fs/promises for rename/unlink (no Bun equivalent for structure ops)
-import { mkdir, rename, unlink } from "node:fs/promises";
+import { copyFile, mkdir, rename, unlink } from "node:fs/promises";
 // node:os platform/homedir/tmpdir: no Bun equivalent
 import { homedir, platform as getPlatform, tmpdir } from "node:os";
 // node:path dirname/join/parse: no Bun equivalent
@@ -48,6 +48,17 @@ export async function renameFilePath(
   await rename(currentPath, nextPath);
 }
 
+export async function copyFilePath(
+  currentPath: string,
+  nextPath: string
+): Promise<void> {
+  await copyFile(currentPath, nextPath);
+}
+
+export async function createFolderPath(path: string): Promise<void> {
+  await mkdir(path, { recursive: true });
+}
+
 type TrashFileDeps = {
   homeDir?: string;
   platform?: ReturnType<typeof getPlatform>;

package/src/core/file-refactors.ts

@@ -0,0 +1,180 @@
+/**
+ * Shared file refactor planning helpers.
+ *
+ * Browser-safe path planning, with warning generation based on known link data.
+ *
+ * @module src/core/file-refactors
+ */
+
+// node:path has no Bun equivalent
+import { posix as pathPosix } from "node:path";
+
+import { validateRelPath } from "./validation";
+
+export interface RefactorWarningSummary {
+  warnings: string[];
+  backlinkCount: number;
+  wikiLinkCount: number;
+  markdownLinkCount: number;
+}
+
+export interface RefactorLinkSnapshot {
+  backlinks: number;
+  wikiLinks: number;
+  markdownLinks: number;
+}
+
+export interface RenamePlan {
+  nextRelPath: string;
+  nextUri: string;
+}
+
+export interface MovePlan {
+  nextRelPath: string;
+  nextUri: string;
+}
+
+export interface DuplicatePlan {
+  nextRelPath: string;
+  nextUri: string;
+}
+
+export function buildRefactorWarnings(
+  snapshot: RefactorLinkSnapshot,
+  options: {
+    filenameChanged?: boolean;
+    folderChanged?: boolean;
+  } = {}
+): RefactorWarningSummary {
+  const warnings: string[] = [];
+
+  if (snapshot.backlinks > 0) {
+    warnings.push(
+      `${snapshot.backlinks} backlink${snapshot.backlinks === 1 ? "" : "s"} may need review after this refactor.`
+    );
+  }
+  if (options.filenameChanged && snapshot.wikiLinks > 0) {
+    warnings.push(
+      `${snapshot.wikiLinks} wiki link${snapshot.wikiLinks === 1 ? "" : "s"} may depend on the current title/path identity.`
+    );
+  }
+  if (
+    (options.filenameChanged || options.folderChanged) &&
+    snapshot.markdownLinks > 0
+  ) {
+    warnings.push(
+      `${snapshot.markdownLinks} markdown link${snapshot.markdownLinks === 1 ? "" : "s"} may require path rewrite or manual review.`
+    );
+  }
+
+  return {
+    warnings,
+    backlinkCount: snapshot.backlinks,
+    wikiLinkCount: snapshot.wikiLinks,
+    markdownLinkCount: snapshot.markdownLinks,
+  };
+}
+
+function nextAvailableRelPath(relPath: string, existing: Set<string>): string {
+  const parsed = pathPosix.parse(relPath);
+  const dir = parsed.dir ? `${parsed.dir}/` : "";
+  const base = parsed.name || "copy";
+  const ext = parsed.ext || ".md";
+
+  let counter = 2;
+  while (true) {
+    const candidate = `${dir}${base}-${counter}${ext}`;
+    if (!existing.has(candidate)) {
+      return candidate;
+    }
+    counter += 1;
+  }
+}
+
+export function planRenameRefactor(input: {
+  collection: string;
+  currentRelPath: string;
+  nextName: string;
+}): RenamePlan {
+  const current = validateRelPath(input.currentRelPath);
+  const directory = pathPosix.dirname(current);
+  const currentExt = pathPosix.extname(current);
+  const nextFilename = pathPosix.extname(input.nextName)
+    ? input.nextName
+    : `${input.nextName}${currentExt}`;
+  const nextRelPath =
+    directory === "."
+      ? validateRelPath(nextFilename)
+      : validateRelPath(`${directory}/${nextFilename}`);
+
+  return {
+    nextRelPath,
+    nextUri: `gno://${input.collection}/${nextRelPath}`,
+  };
+}
+
+export function planMoveRefactor(input: {
+  collection: string;
+  currentRelPath: string;
+  folderPath: string;
+  nextName?: string;
+}): MovePlan {
+  const current = validateRelPath(input.currentRelPath);
+  const safeFolder = validateRelPath(input.folderPath).replace(
+    /^\.\/|\/+$/g,
+    ""
+  );
+  const filename = input.nextName?.trim() || pathPosix.basename(current);
+  const nextRelPath = safeFolder
+    ? validateRelPath(`${safeFolder}/${filename}`)
+    : validateRelPath(filename);
+
+  return {
+    nextRelPath,
+    nextUri: `gno://${input.collection}/${nextRelPath}`,
+  };
+}
+
+export function planDuplicateRefactor(input: {
+  collection: string;
+  currentRelPath: string;
+  folderPath?: string;
+  nextName?: string;
+  existingRelPaths: Iterable<string>;
+}): DuplicatePlan {
+  const current = validateRelPath(input.currentRelPath);
+  const existing = new Set(input.existingRelPaths);
+  const targetFolder = input.folderPath
+    ? validateRelPath(input.folderPath).replace(/^\.\/|\/+$/g, "")
+    : pathPosix.dirname(current) === "."
+      ? ""
+      : pathPosix.dirname(current);
+  const baseName = input.nextName?.trim() || pathPosix.basename(current);
+  const initialRelPath = targetFolder
+    ? validateRelPath(`${targetFolder}/${baseName}`)
+    : validateRelPath(baseName);
+  const nextRelPath = existing.has(initialRelPath)
+    ? nextAvailableRelPath(initialRelPath, existing)
+    : initialRelPath;
+
+  return {
+    nextRelPath,
+    nextUri: `gno://${input.collection}/${nextRelPath}`,
+  };
+}
+
+export function planCreateFolder(input: {
+  parentPath?: string;
+  name: string;
+}): string {
+  const safeName = input.name.trim().replaceAll(/[\\/]+/g, "");
+  if (!safeName) {
+    throw new Error("Folder name cannot be empty");
+  }
+  const safeParent = input.parentPath
+    ? validateRelPath(input.parentPath).replace(/^\.\/|\/+$/g, "")
+    : "";
+  return safeParent
+    ? validateRelPath(`${safeParent}/${safeName}`)
+    : validateRelPath(safeName);
+}

package/src/core/note-creation.ts

@@ -0,0 +1,137 @@
+/**
+ * Shared note creation path resolution and collision handling.
+ *
+ * Browser-safe: no Bun APIs.
+ *
+ * @module src/core/note-creation
+ */
+
+// node:path has no Bun equivalent
+import { posix as pathPosix } from "node:path";
+
+import { validateRelPath } from "./validation";
+
+export type NoteCollisionPolicy =
+  | "error"
+  | "open_existing"
+  | "create_with_suffix";
+
+export interface ResolveNoteCreateInput {
+  collection: string;
+  title?: string;
+  relPath?: string;
+  folderPath?: string;
+  collisionPolicy?: NoteCollisionPolicy;
+}
+
+export interface NoteCreatePlan {
+  collection: string;
+  folderPath: string;
+  relPath: string;
+  filename: string;
+  collisionPolicy: NoteCollisionPolicy;
+  openedExisting: boolean;
+  createdWithSuffix: boolean;
+}
+
+export function sanitizeNoteFilename(title: string): string {
+  return title
+    .normalize("NFC")
+    .toLowerCase()
+    .trim()
+    .replaceAll(/[^\w\s-]/g, "")
+    .replaceAll(/\s+/g, "-")
+    .replaceAll(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+function ensureMarkdownFilename(filename: string): string {
+  return pathPosix.extname(filename) ? filename : `${filename}.md`;
+}
+
+function nextAvailableRelPath(relPath: string, existing: Set<string>): string {
+  const parsed = pathPosix.parse(relPath);
+  const ext = parsed.ext || ".md";
+  const dir = parsed.dir ? `${parsed.dir}/` : "";
+  const base = parsed.name || "untitled";
+
+  let counter = 2;
+  while (true) {
+    const candidate = `${dir}${base}-${counter}${ext}`;
+    if (!existing.has(candidate)) {
+      return candidate;
+    }
+    counter += 1;
+  }
+}
+
+export function resolveNoteCreatePlan(
+  input: ResolveNoteCreateInput,
+  existingRelPaths: Iterable<string>
+): NoteCreatePlan {
+  const collisionPolicy = input.collisionPolicy ?? "error";
+  const existing = new Set(existingRelPaths);
+  const safeFolderPath = input.folderPath
+    ? validateRelPath(input.folderPath).replace(/^\.\/|\/+$/g, "")
+    : "";
+
+  let baseRelPath: string;
+  if (input.relPath?.trim()) {
+    baseRelPath = validateRelPath(input.relPath.trim());
+  } else {
+    const baseTitle = input.title?.trim() || "untitled";
+    const filename = ensureMarkdownFilename(
+      sanitizeNoteFilename(baseTitle) || "untitled"
+    );
+    baseRelPath = safeFolderPath ? `${safeFolderPath}/${filename}` : filename;
+  }
+
+  const relPath = safeFolderPath
+    ? baseRelPath.startsWith(`${safeFolderPath}/`) ||
+      baseRelPath === safeFolderPath
+      ? baseRelPath
+      : `${safeFolderPath}/${pathPosix.basename(baseRelPath)}`
+    : baseRelPath;
+  const normalizedRelPath = validateRelPath(relPath);
+
+  if (!existing.has(normalizedRelPath)) {
+    return {
+      collection: input.collection,
+      folderPath: safeFolderPath,
+      relPath: normalizedRelPath,
+      filename: pathPosix.basename(normalizedRelPath),
+      collisionPolicy,
+      openedExisting: false,
+      createdWithSuffix: false,
+    };
+  }
+
+  if (collisionPolicy === "open_existing") {
+    return {
+      collection: input.collection,
+      folderPath: safeFolderPath,
+      relPath: normalizedRelPath,
+      filename: pathPosix.basename(normalizedRelPath),
+      collisionPolicy,
+      openedExisting: true,
+      createdWithSuffix: false,
+    };
+  }
+
+  if (collisionPolicy === "create_with_suffix") {
+    const nextRelPath = nextAvailableRelPath(normalizedRelPath, existing);
+    return {
+      collection: input.collection,
+      folderPath: safeFolderPath,
+      relPath: nextRelPath,
+      filename: pathPosix.basename(nextRelPath),
+      collisionPolicy,
+      openedExisting: false,
+      createdWithSuffix: true,
+    };
+  }
+
+  throw new Error(
+    "File already exists. Use open_existing or create_with_suffix."
+  );
+}

package/src/core/note-presets.ts

@@ -0,0 +1,183 @@
+/**
+ * Shared note preset definitions and scaffold helpers.
+ *
+ * Browser-safe: no Bun APIs.
+ *
+ * @module src/core/note-presets
+ */
+
+import { normalizeTag } from "./tags";
+
+export type NotePresetId =
+  | "blank"
+  | "project-note"
+  | "research-note"
+  | "decision-note"
+  | "prompt-pattern"
+  | "source-summary";
+
+export interface NotePresetDefinition {
+  id: NotePresetId;
+  label: string;
+  description: string;
+  defaultTags?: string[];
+  frontmatter?: Record<string, string | string[]>;
+  body: (title: string) => string;
+}
+
+export interface ResolvedNotePreset {
+  preset: NotePresetDefinition;
+  title: string;
+  tags: string[];
+  frontmatter: Record<string, string | string[]>;
+  body: string;
+  content: string;
+}
+
+function serializeFrontmatterValue(value: string | string[]): string[] {
+  if (Array.isArray(value)) {
+    return value.length === 0
+      ? []
+      : value.map((entry) => `  - ${JSON.stringify(entry)}`);
+  }
+  return [JSON.stringify(value)];
+}
+
+export function serializeFrontmatter(
+  data: Record<string, string | string[]>
+): string {
+  const entries = Object.entries(data);
+  if (entries.length === 0) {
+    return "";
+  }
+
+  const lines = ["---"];
+  for (const [key, value] of entries) {
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        lines.push(`${key}: []`);
+        continue;
+      }
+      lines.push(`${key}:`);
+    } else {
+      lines.push(`${key}: ${serializeFrontmatterValue(value)[0]}`);
+      continue;
+    }
+    for (const line of serializeFrontmatterValue(value)) {
+      lines.push(line);
+    }
+  }
+  lines.push("---", "");
+  return lines.join("\n");
+}
+
+export const NOTE_PRESETS: NotePresetDefinition[] = [
+  {
+    id: "blank",
+    label: "Blank",
+    description: "Empty note with only a title heading.",
+    body: (title) => `# ${title}\n`,
+  },
+  {
+    id: "project-note",
+    label: "Project Note",
+    description: "Goal, scope, open questions, and next steps.",
+    defaultTags: ["project"],
+    frontmatter: {
+      category: "project",
+      status: "active",
+    },
+    body: (title) =>
+      `# ${title}\n\n## Goal\n\n## Scope\n\n## Open Questions\n\n## Next Steps\n`,
+  },
+  {
+    id: "research-note",
+    label: "Research Note",
+    description: "Summary, key ideas, evidence, and follow-up questions.",
+    defaultTags: ["research"],
+    frontmatter: {
+      category: "research",
+    },
+    body: (title) =>
+      `# ${title}\n\n## Summary\n\n## Key Ideas\n\n## Evidence\n\n## Follow-up Questions\n`,
+  },
+  {
+    id: "decision-note",
+    label: "Decision Note",
+    description: "Context, decision, rationale, and consequences.",
+    defaultTags: ["decision"],
+    frontmatter: {
+      category: "decision",
+      status: "proposed",
+    },
+    body: (title) =>
+      `# ${title}\n\n## Context\n\n## Decision\n\n## Rationale\n\n## Consequences\n`,
+  },
+  {
+    id: "prompt-pattern",
+    label: "Prompt / Pattern",
+    description: "Capture reusable prompts, constraints, and examples.",
+    defaultTags: ["prompt", "pattern"],
+    frontmatter: {
+      category: "pattern",
+    },
+    body: (title) =>
+      `# ${title}\n\n## Use Case\n\n## Prompt\n\n## Constraints\n\n## Example\n`,
+  },
+  {
+    id: "source-summary",
+    label: "Source Summary",
+    description: "Summarize an article, paper, or external source cleanly.",
+    defaultTags: ["source", "summary"],
+    frontmatter: {
+      category: "source-summary",
+      sources: [],
+    },
+    body: (title) =>
+      `# ${title}\n\n## Summary\n\n## Important Claims\n\n## Evidence / Quotes\n\n## Takeaways\n`,
+  },
+];
+
+export function getNotePreset(
+  presetId?: string | null
+): NotePresetDefinition | null {
+  if (!presetId) {
+    return null;
+  }
+  return NOTE_PRESETS.find((preset) => preset.id === presetId) ?? null;
+}
+
+export function resolveNotePreset(input: {
+  presetId?: string | null;
+  title: string;
+  tags?: string[];
+  frontmatter?: Record<string, string | string[]>;
+  body?: string;
+}): ResolvedNotePreset | null {
+  const preset = getNotePreset(input.presetId);
+  if (!preset) {
+    return null;
+  }
+
+  const title = input.title.trim() || "Untitled";
+  const presetTags = (preset.defaultTags ?? []).map(normalizeTag);
+  const tags = [
+    ...new Set([...(input.tags ?? []).map(normalizeTag), ...presetTags]),
+  ];
+  const frontmatter = {
+    ...preset.frontmatter,
+    ...input.frontmatter,
+    ...(tags.length > 0 ? { tags } : {}),
+  };
+  const body = input.body?.trim().length ? input.body : preset.body(title);
+  const frontmatterBlock = serializeFrontmatter(frontmatter);
+
+  return {
+    preset,
+    title,
+    tags,
+    frontmatter,
+    body,
+    content: `${frontmatterBlock}${body}`.trimEnd() + "\n",
+  };
+}