pi-weave 0.1.16 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-weave",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "An agent-native knowledge workspace for your life and your code. Smart notepad + repository exploration, readable by humans and agents alike.",
   "type": "module",
   "sideEffects": false,

package/src/core/index.ts

@@ -17,6 +17,8 @@ export { runDeepScan, type DeepScanOptions, type DeepScanResult, type SummarizeF
 export {
   addNote,
   appendToNote,
+  deleteFolder,
+  deleteNote,
   extractRawTail,
   finalizeNote,
   formatNote,
@@ -24,7 +26,10 @@ export {
   getHtmlArtifact,
   getNote,
   listNotes,
+  moveNote,
   parseHtmlArtifact,
+  renameFolder,
+  renameNote,
   resolveHtmlPath,
   resolveNotePath,
   searchNotes,

package/src/core/vault.ts

@@ -99,7 +99,7 @@ export function resolveNotePath(root: string, slug: string): string | null {
  */
 export async function addNote(root: string, input: AddNoteInput): Promise<Note> {
   await ensureVault(root);
-  return withNoteLocks([join(root, NOTES_DIR)], async () => {
+  return withVaultLock(root, async () => {
     const now = (input.now ?? new Date()).toISOString();
     const base = slugify(input.title);
     const slug = uniqueSlug(base, (candidate) => existsSync(notePath(root, candidate)));
@@ -183,18 +183,12 @@ async function writeNote(
 const LOCK_NS = "vault:note:";
 
 /**
- * Run `task` with exclusive access to every given note path.
- *
- * Paths are locked in a fixed order so callers that need multiple locks cannot
- * deadlock. Every mutation in this module goes through here, keeping appends
- * and finalization serialized with one another.
+ * Run `task` with exclusive mutation access to this vault.
  */
-function withNoteLocks<T>(paths: readonly string[], task: () => Promise<T>): Promise<T> {
-  const ordered = [...new Set(paths)].sort();
-  return ordered.reduceRight<() => Promise<T>>(
-    (inner, path) => () => withMutationQueue(LOCK_NS + path, inner),
-    task,
-  )();
+function withVaultLock<T>(root: string, task: () => Promise<T>): Promise<T> {
+  // ponytail: one vault-wide lock is enough for a local notepad; use
+  // hierarchical locks only if independent-note write throughput matters.
+  return withMutationQueue(LOCK_NS + join(root, NOTES_DIR), task);
 }
 
 /** Options for {@link appendToNote}. */
@@ -219,7 +213,7 @@ export async function appendToNote(
 ): Promise<Note | null> {
   const path = resolveNotePath(root, slug);
   if (!path) return null;
-  return withNoteLocks([path], async () => {
+  return withVaultLock(root, async () => {
     const note = await getNote(root, slug);
     if (!note) return null;
     const tail = extractRawTail(note.body);
@@ -326,7 +320,7 @@ export async function finalizeNote(
 ): Promise<Note | null> {
   const path = resolveNotePath(root, slug);
   if (!path) return null;
-  return withNoteLocks([path], async () => {
+  return withVaultLock(root, async () => {
     const note = await getNote(root, slug);
     if (!note) return null;
     const rawTail = extractRawTail(note.body);
@@ -347,6 +341,103 @@ export async function finalizeNote(
   });
 }
 
+export type VaultMutationResult =
+  | { ok: true; slug?: string; path?: string }
+  | { ok: false; reason: "missing" | "collision" | "invalid" };
+
+function resolveFolderPath(root: string, folder: string): string | null {
+  const parts = folder.split("/");
+  if (parts.length === 0 || parts.some((part) => part === "" || part === "." || part === "..")) return null;
+  const notesDir = join(root, NOTES_DIR);
+  const candidate = join(notesDir, ...parts);
+  const rel = relative(notesDir, candidate);
+  return rel.startsWith("..") || isAbsolute(rel) || rel.length === 0 ? null : candidate;
+}
+
+async function isDirectory(path: string): Promise<boolean> {
+  try {
+    return (await fs.stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/** Rename a note in place and keep its front-matter title in sync. */
+export async function renameNote(root: string, slug: string, name: string, now = new Date()): Promise<VaultMutationResult> {
+  const from = resolveNotePath(root, slug);
+  const title = name.trim();
+  if (from === null || title === "") return { ok: false, reason: "invalid" };
+  const parent = slug.split("/").slice(0, -1).join("/");
+  const target = [...(parent === "" ? [] : [parent]), slugify(title)].join("/");
+  const to = resolveNotePath(root, target);
+  if (to === null) return { ok: false, reason: "invalid" };
+  return withVaultLock(root, async () => {
+    const note = await getNote(root, slug);
+    if (note === null) return { ok: false, reason: "missing" };
+    if (from !== to && await exists(to)) return { ok: false, reason: "collision" };
+    if (from !== to) await fs.rename(from, to);
+    await writeNote(to, target, { ...note, title, updated: now.toISOString() }, note.body, note.frontMatter);
+    return { ok: true, slug: target };
+  });
+}
+
+/** Move a note to an existing vault folder, or to the vault root with `null`. */
+export async function moveNote(root: string, slug: string, folder: string | null): Promise<VaultMutationResult> {
+  const from = resolveNotePath(root, slug);
+  if (from === null) return { ok: false, reason: "invalid" };
+  const targetDir = folder === null ? join(root, NOTES_DIR) : resolveFolderPath(root, folder);
+  if (targetDir === null || !(await isDirectory(targetDir))) return { ok: false, reason: "missing" };
+  const target = folder === null ? basename(slug) : `${folder}/${basename(slug)}`;
+  const to = resolveNotePath(root, target);
+  if (to === null) return { ok: false, reason: "invalid" };
+  return withVaultLock(root, async () => {
+    if (!(await exists(from))) return { ok: false, reason: "missing" };
+    if (from === to) return { ok: true, slug };
+    if (await exists(to)) return { ok: false, reason: "collision" };
+    await fs.rename(from, to);
+    return { ok: true, slug: target };
+  });
+}
+
+/** Permanently delete one note. */
+export async function deleteNote(root: string, slug: string): Promise<VaultMutationResult> {
+  const path = resolveNotePath(root, slug);
+  if (path === null) return { ok: false, reason: "invalid" };
+  return withVaultLock(root, async () => {
+    if (!(await exists(path))) return { ok: false, reason: "missing" };
+    await fs.unlink(path);
+    return { ok: true };
+  });
+}
+
+/** Rename a vault folder without changing its parent. */
+export async function renameFolder(root: string, folder: string, name: string): Promise<VaultMutationResult> {
+  const from = resolveFolderPath(root, folder);
+  const title = name.trim();
+  if (from === null || title === "") return { ok: false, reason: "invalid" };
+  const parent = folder.split("/").slice(0, -1).join("/");
+  const target = [...(parent === "" ? [] : [parent]), slugify(title)].join("/");
+  const to = resolveFolderPath(root, target);
+  if (to === null) return { ok: false, reason: "invalid" };
+  return withVaultLock(root, async () => {
+    if (!(await isDirectory(from))) return { ok: false, reason: "missing" };
+    if (from !== to && await exists(to)) return { ok: false, reason: "collision" };
+    if (from !== to) await fs.rename(from, to);
+    return { ok: true, path: target };
+  });
+}
+
+/** Permanently delete a vault folder and its contents. */
+export async function deleteFolder(root: string, folder: string): Promise<VaultMutationResult> {
+  const path = resolveFolderPath(root, folder);
+  if (path === null) return { ok: false, reason: "invalid" };
+  return withVaultLock(root, async () => {
+    if (!(await isDirectory(path))) return { ok: false, reason: "missing" };
+    await fs.rm(path, { recursive: true });
+    return { ok: true };
+  });
+}
+
 async function listVaultEntries(root: string): Promise<{ files: string[]; folders: string[] }> {
   const dir = join(root, NOTES_DIR);
   const files: string[] = [];

package/src/web/client/api.ts

@@ -36,7 +36,7 @@
  * fortnight.
  */
 
-import type { GraphPayload, NotePayload, OpenResult, SearchPayload, ViewNote } from "../shared/wire";
+import type { GraphPayload, MutationResult, NotePayload, OpenResult, SearchPayload, ViewNote } from "../shared/wire";
 
 // --- the injected HTTP port ------------------------------------------------------
 
@@ -229,6 +229,10 @@ export function isOpenResult(value: unknown): value is OpenResult {
   return isObject(value) && typeof value["opened"] === "boolean";
 }
 
+export function isMutationResult(value: unknown): value is MutationResult {
+  return isObject(value) && value["ok"] === true && (value["id"] === undefined || typeof value["id"] === "string");
+}
+
 // --- routes --------------------------------------------------------------------------
 
 /**
@@ -308,3 +312,19 @@ export function openNote(fetchImpl: FetchLike, slug: string): Promise<ApiResult<
     body: JSON.stringify({ slug }),
   });
 }
+
+function mutation(fetchImpl: FetchLike, url: string, method: string, body?: unknown): Promise<ApiResult<MutationResult>> {
+  return request(fetchImpl, url, isMutationResult, {
+    method,
+    ...(body === undefined ? {} : { headers: { "content-type": "application/json" }, body: JSON.stringify(body) }),
+  });
+}
+
+const noteUrl = (slug: string, suffix = ""): string => `/api/note/${encodeURIComponent(slug)}${suffix}`;
+const folderUrl = (path: string, suffix = ""): string => `/api/folder/${path.split("/").map(encodeURIComponent).join("/")}${suffix}`;
+
+export const renameNote = (fetchImpl: FetchLike, slug: string, name: string) => mutation(fetchImpl, noteUrl(slug, "/rename"), "POST", { name });
+export const moveNote = (fetchImpl: FetchLike, slug: string, folder: string | null) => mutation(fetchImpl, noteUrl(slug, "/move"), "POST", { folder });
+export const deleteNote = (fetchImpl: FetchLike, slug: string) => mutation(fetchImpl, noteUrl(slug), "DELETE");
+export const renameFolder = (fetchImpl: FetchLike, path: string, name: string) => mutation(fetchImpl, folderUrl(path, "/rename"), "POST", { name });
+export const deleteFolder = (fetchImpl: FetchLike, path: string) => mutation(fetchImpl, folderUrl(path), "DELETE");