@vellumai/assistant 0.5.1 → 0.5.2

package/src/__tests__/app-builder-tool-scripts.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, mock, test } from "bun:test";
 
 import type { AppDefinition } from "../memory/app-store.js";
 import type { AppStore } from "../tools/apps/executors.js";
-import type { EditEngineResult } from "../tools/shared/filesystem/edit-engine.js";
 import type { ToolContext } from "../tools/types.js";
 
 // ---------------------------------------------------------------------------
@@ -26,24 +25,11 @@ function makeMockStore(overrides: Partial<AppStore> = {}): AppStore {
   return {
     getApp: () => makeApp(),
     listApps: () => [makeApp()],
-    queryAppRecords: () => [],
-    listAppFiles: () => ["index.html"],
-    readAppFile: () => "<h1>Hi</h1>",
     createApp: (params) =>
       makeApp({ name: params.name, description: params.description }),
     updateApp: (id, updates) => makeApp({ id, ...updates }),
     deleteApp: () => {},
     writeAppFile: () => {},
-    editAppFile: () =>
-      ({
-        ok: true,
-        updatedContent: "new",
-        matchCount: 1,
-        matchMethod: "exact",
-        similarity: 1,
-        actualOld: "old",
-        actualNew: "new",
-      }) as EditEngineResult,
     ...overrides,
   };
 }
@@ -66,6 +52,11 @@ const mockStore = makeMockStore();
 mock.module("../memory/app-store.js", () => ({
   ...mockStore,
   getAppsDir: () => "/tmp/test-apps",
+  getAppDirPath: (appId: string) => `/tmp/test-apps/${appId}`,
+  resolveAppDir: (id: string) => ({
+    dirName: id,
+    appDir: `/tmp/test-apps/${id}`,
+  }),
   isMultifileApp: (app: AppDefinition) => app.formatVersion === 2,
 }));
 
@@ -85,13 +76,7 @@ mock.module("../bundler/app-compiler.js", () => ({
 
 import * as appCreateScript from "../config/bundled-skills/app-builder/tools/app-create.js";
 import * as appDeleteScript from "../config/bundled-skills/app-builder/tools/app-delete.js";
-import * as appFileEditScript from "../config/bundled-skills/app-builder/tools/app-file-edit.js";
-import * as appFileListScript from "../config/bundled-skills/app-builder/tools/app-file-list.js";
-import * as appFileReadScript from "../config/bundled-skills/app-builder/tools/app-file-read.js";
-import * as appFileWriteScript from "../config/bundled-skills/app-builder/tools/app-file-write.js";
-import * as appListScript from "../config/bundled-skills/app-builder/tools/app-list.js";
-import * as appQueryScript from "../config/bundled-skills/app-builder/tools/app-query.js";
-import * as appUpdateScript from "../config/bundled-skills/app-builder/tools/app-update.js";
+import * as appRefreshScript from "../config/bundled-skills/app-builder/tools/app-refresh.js";
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -142,58 +127,6 @@ describe("app-builder skill tool scripts", () => {
     });
   });
 
-  // ---- app-list ----------------------------------------------------------
-
-  describe("app-list", () => {
-    test("exports a run function", () => {
-      expect(typeof appListScript.run).toBe("function");
-    });
-
-    test("delegates to executeAppList and returns result", async () => {
-      const result = await appListScript.run({}, makeContext());
-      expect(result.isError).toBe(false);
-      const parsed = JSON.parse(result.content);
-      expect(Array.isArray(parsed)).toBe(true);
-      expect(parsed.length).toBeGreaterThan(0);
-      expect(parsed[0].id).toBe("app-1");
-    });
-  });
-
-  // ---- app-query ---------------------------------------------------------
-
-  describe("app-query", () => {
-    test("exports a run function", () => {
-      expect(typeof appQueryScript.run).toBe("function");
-    });
-
-    test("delegates to executeAppQuery and returns result", async () => {
-      const result = await appQueryScript.run(
-        { app_id: "app-1" },
-        makeContext(),
-      );
-      expect(result.isError).toBe(false);
-      expect(JSON.parse(result.content)).toEqual([]);
-    });
-  });
-
-  // ---- app-update --------------------------------------------------------
-
-  describe("app-update", () => {
-    test("exports a run function", () => {
-      expect(typeof appUpdateScript.run).toBe("function");
-    });
-
-    test("delegates to executeAppUpdate and returns result", async () => {
-      const result = await appUpdateScript.run(
-        { app_id: "app-1", name: "Updated" },
-        makeContext(),
-      );
-      expect(result.isError).toBe(false);
-      const parsed = JSON.parse(result.content);
-      expect(parsed.name).toBe("Updated");
-    });
-  });
-
   // ---- app-delete --------------------------------------------------------
 
   describe("app-delete", () => {
@@ -213,93 +146,22 @@ describe("app-builder skill tool scripts", () => {
     });
   });
 
-  // ---- app-file-list -----------------------------------------------------
+  // ---- app-refresh -------------------------------------------------------
 
-  describe("app-file-list", () => {
+  describe("app-refresh", () => {
     test("exports a run function", () => {
-      expect(typeof appFileListScript.run).toBe("function");
+      expect(typeof appRefreshScript.run).toBe("function");
     });
 
-    test("delegates to executeAppFileList and returns result", async () => {
-      const result = await appFileListScript.run(
+    test("delegates to executeAppRefresh and returns result", async () => {
+      const result = await appRefreshScript.run(
         { app_id: "app-1" },
         makeContext(),
       );
       expect(result.isError).toBe(false);
-      expect(JSON.parse(result.content)).toEqual(["index.html"]);
-    });
-  });
-
-  // ---- app-file-read -----------------------------------------------------
-
-  describe("app-file-read", () => {
-    test("exports a run function", () => {
-      expect(typeof appFileReadScript.run).toBe("function");
-    });
-
-    test("delegates to executeAppFileRead and returns formatted content", async () => {
-      const result = await appFileReadScript.run(
-        { app_id: "app-1", path: "index.html" },
-        makeContext(),
-      );
-      expect(result.isError).toBe(false);
-      // Content should include line numbers
-      expect(result.content).toContain("1\t");
-    });
-  });
-
-  // ---- app-file-edit -----------------------------------------------------
-
-  describe("app-file-edit", () => {
-    test("exports a run function", () => {
-      expect(typeof appFileEditScript.run).toBe("function");
-    });
-
-    test("delegates to executeAppFileEdit and returns result", async () => {
-      const result = await appFileEditScript.run(
-        {
-          app_id: "app-1",
-          path: "index.html",
-          old_string: "old",
-          new_string: "new",
-        },
-        makeContext(),
-      );
-      expect(result.isError).toBe(false);
       const parsed = JSON.parse(result.content);
-      expect(parsed.ok).toBe(true);
-    });
-
-    test("returns error when old_string is empty", async () => {
-      const result = await appFileEditScript.run(
-        {
-          app_id: "app-1",
-          path: "index.html",
-          old_string: "",
-          new_string: "new",
-        },
-        makeContext(),
-      );
-      expect(result.isError).toBe(true);
-    });
-  });
-
-  // ---- app-file-write ----------------------------------------------------
-
-  describe("app-file-write", () => {
-    test("exports a run function", () => {
-      expect(typeof appFileWriteScript.run).toBe("function");
-    });
-
-    test("delegates to executeAppFileWrite and returns result", async () => {
-      const result = await appFileWriteScript.run(
-        { app_id: "app-1", path: "new.html", content: "<div/>" },
-        makeContext(),
-      );
-      expect(result.isError).toBe(false);
-      const parsed = JSON.parse(result.content);
-      expect(parsed.written).toBe(true);
-      expect(parsed.path).toBe("new.html");
+      expect(parsed.refreshed).toBe(true);
+      expect(parsed.appId).toBe("app-1");
     });
   });
 });

package/src/__tests__/app-dir-path-guard.test.ts

@@ -0,0 +1,78 @@
+import { execSync } from "node:child_process";
+import { describe, expect, test } from "bun:test";
+
+/**
+ * Guard test: files outside app-store.ts must not import getAppsDir and use
+ * it to construct paths with an app ID. All app path construction must go
+ * through getAppDirPath() or resolveAppDir() from app-store.ts.
+ *
+ * This prevents regressions where new code bypasses the dirName-based path
+ * resolution and constructs UUID-based paths directly.
+ *
+ * Allowlist: only app-store.ts itself, app-git-service.ts (uses getAppsDir
+ * for the git repo root, not for per-app paths), and workspace migrations
+ * (self-contained, don't import from app-store).
+ */
+
+/** Files that are permitted to import getAppsDir. */
+const ALLOWLIST = new Set([
+  "assistant/src/memory/app-store.ts", // defines getAppsDir
+  "assistant/src/memory/app-git-service.ts", // uses getAppsDir for git repo root, not per-app paths
+]);
+
+function isTestFile(filePath: string): boolean {
+  return (
+    filePath.includes("/__tests__/") ||
+    filePath.endsWith(".test.ts") ||
+    filePath.endsWith(".test.js") ||
+    filePath.endsWith(".spec.ts")
+  );
+}
+
+function isMigrationFile(filePath: string): boolean {
+  return filePath.includes("/workspace/migrations/");
+}
+
+describe("app directory path construction guard", () => {
+  test("no non-allowlisted production files import getAppsDir", () => {
+    // Search for files that import getAppsDir (not just mention it in comments)
+    const pattern = "import.*getAppsDir.*from|getAppsDir\\(\\)";
+
+    let grepOutput = "";
+    try {
+      grepOutput = execSync(`git grep -lE '${pattern}' -- '*.ts'`, {
+        encoding: "utf-8",
+        cwd: process.cwd() + "/..",
+      }).trim();
+    } catch (err) {
+      // Exit code 1 means no matches
+      if ((err as { status?: number }).status === 1) {
+        return;
+      }
+      throw err;
+    }
+
+    const files = grepOutput.split("\n").filter((f) => f.length > 0);
+    const violations = files.filter((f) => {
+      if (isTestFile(f)) return false;
+      if (isMigrationFile(f)) return false;
+      if (ALLOWLIST.has(f)) return false;
+      return true;
+    });
+
+    if (violations.length > 0) {
+      const message = [
+        "Found non-allowlisted production files importing or using getAppsDir().",
+        "Use getAppDirPath(appId) or resolveAppDir(appId) from app-store.ts instead.",
+        "",
+        "Violations:",
+        ...violations.map((f) => `  - ${f}`),
+        "",
+        "To fix: replace getAppsDir() + appId path construction with getAppDirPath(appId).",
+        "If this is an intentional exception, add it to the ALLOWLIST in app-dir-path-guard.test.ts.",
+      ].join("\n");
+
+      expect(violations, message).toEqual([]);
+    }
+  });
+});

package/src/__tests__/app-executors.test.ts

@@ -11,14 +11,7 @@ mock.module("../bundler/app-compiler.js", () => ({
 
 import type { AppDefinition } from "../memory/app-store.js";
 import type { AppStore } from "../tools/apps/executors.js";
-import {
-  executeAppCreate,
-  executeAppFileEdit,
-  executeAppFileList,
-  executeAppFileRead,
-  executeAppFileWrite,
-  resolveAppFilePath,
-} from "../tools/apps/executors.js";
+import { executeAppCreate } from "../tools/apps/executors.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -60,298 +53,15 @@ function mockStore(
   return {
     getApp: (id: string) => (id === app.id ? app : null),
     listApps: () => [app],
-    queryAppRecords: () => [],
-    listAppFiles: () => Object.keys(files).sort(),
-    readAppFile: (_appId: string, path: string) => {
-      if (!(path in files)) throw new Error(`File not found: ${path}`);
-      return files[path];
-    },
     createApp: () => app,
     updateApp: () => app,
     deleteApp: () => {},
     writeAppFile: (_appId: string, path: string, content: string) => {
       files[path] = content;
     },
-    editAppFile: (
-      _appId: string,
-      path: string,
-      oldStr: string,
-      newStr: string,
-      _replaceAll?: boolean,
-    ) => {
-      if (!(path in files)) throw new Error(`File not found: ${path}`);
-      const content = files[path];
-      if (!content.includes(oldStr)) {
-        return { ok: false as const, reason: "not_found" as const };
-      }
-      const updated = content.replace(oldStr, newStr);
-      files[path] = updated;
-      return {
-        ok: true as const,
-        updatedContent: updated,
-        matchCount: 1,
-        matchMethod: "exact" as const,
-        similarity: 1,
-        actualOld: oldStr,
-        actualNew: newStr,
-      };
-    },
   };
 }
 
-// ---------------------------------------------------------------------------
-// resolveAppFilePath
-// ---------------------------------------------------------------------------
-
-describe("resolveAppFilePath", () => {
-  test("prepends src/ for multifile app with plain path", () => {
-    const app = makeMultifileApp();
-    expect(resolveAppFilePath(app, "main.tsx")).toBe("src/main.tsx");
-  });
-
-  test("prepends src/ for nested path in multifile app", () => {
-    const app = makeMultifileApp();
-    expect(resolveAppFilePath(app, "components/Header.tsx")).toBe(
-      "src/components/Header.tsx",
-    );
-  });
-
-  test("passes through src/ prefix unchanged for multifile app", () => {
-    const app = makeMultifileApp();
-    expect(resolveAppFilePath(app, "src/main.tsx")).toBe("src/main.tsx");
-  });
-
-  test("passes through dist/ prefix unchanged for multifile app", () => {
-    const app = makeMultifileApp();
-    expect(resolveAppFilePath(app, "dist/bundle.js")).toBe("dist/bundle.js");
-  });
-
-  test("passes through records/ prefix unchanged for multifile app", () => {
-    const app = makeMultifileApp();
-    expect(resolveAppFilePath(app, "records/data.json")).toBe(
-      "records/data.json",
-    );
-  });
-
-  test("does not modify path for legacy app", () => {
-    const app = makeLegacyApp();
-    expect(resolveAppFilePath(app, "main.tsx")).toBe("main.tsx");
-  });
-
-  test("does not modify path for legacy app (formatVersion undefined)", () => {
-    const app = makeLegacyApp({ formatVersion: undefined });
-    expect(resolveAppFilePath(app, "styles.css")).toBe("styles.css");
-  });
-
-  test("does not modify path for legacy app (formatVersion 1)", () => {
-    const app = makeLegacyApp({ formatVersion: 1 });
-    expect(resolveAppFilePath(app, "index.html")).toBe("index.html");
-  });
-
-  test("strips ./ prefix and prepends src/ for multifile app", () => {
-    const app = makeMultifileApp();
-    expect(resolveAppFilePath(app, "./main.tsx")).toBe("src/main.tsx");
-  });
-
-  test("strips ./ prefix for known top-level dir in multifile app", () => {
-    const app = makeMultifileApp();
-    expect(resolveAppFilePath(app, "./src/main.tsx")).toBe("src/main.tsx");
-    expect(resolveAppFilePath(app, "./dist/bundle.js")).toBe("dist/bundle.js");
-    expect(resolveAppFilePath(app, "./records/data.json")).toBe(
-      "records/data.json",
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// executeAppFileWrite
-// ---------------------------------------------------------------------------
-
-describe("executeAppFileWrite", () => {
-  test("resolves plain path to src/ for multifile app", () => {
-    const files: Record<string, string> = {};
-    const app = makeMultifileApp();
-    const store = mockStore(app, files);
-
-    const result = executeAppFileWrite(
-      { app_id: app.id, path: "main.tsx", content: "export default 1;" },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(JSON.parse(result.content).path).toBe("src/main.tsx");
-    expect(files["src/main.tsx"]).toBe("export default 1;");
-  });
-
-  test("passes through src/ path unchanged for multifile app", () => {
-    const files: Record<string, string> = {};
-    const app = makeMultifileApp();
-    const store = mockStore(app, files);
-
-    const result = executeAppFileWrite(
-      { app_id: app.id, path: "src/main.tsx", content: "export default 2;" },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(JSON.parse(result.content).path).toBe("src/main.tsx");
-    expect(files["src/main.tsx"]).toBe("export default 2;");
-  });
-
-  test("does not modify path for legacy app", () => {
-    const files: Record<string, string> = {};
-    const app = makeLegacyApp();
-    const store = mockStore(app, files);
-
-    const result = executeAppFileWrite(
-      { app_id: app.id, path: "index.html", content: "<html></html>" },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(JSON.parse(result.content).path).toBe("index.html");
-    expect(files["index.html"]).toBe("<html></html>");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// executeAppFileRead
-// ---------------------------------------------------------------------------
-
-describe("executeAppFileRead", () => {
-  test("resolves plain path to src/ for multifile app", () => {
-    const app = makeMultifileApp();
-    const store = mockStore(app, { "src/main.tsx": "line1\nline2" });
-
-    const result = executeAppFileRead(
-      { app_id: app.id, path: "main.tsx" },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("line1");
-  });
-
-  test("can read dist/ files explicitly for multifile app", () => {
-    const app = makeMultifileApp();
-    const store = mockStore(app, { "dist/bundle.js": "bundled code" });
-
-    const result = executeAppFileRead(
-      { app_id: app.id, path: "dist/bundle.js" },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("bundled code");
-  });
-
-  test("does not modify path for legacy app", () => {
-    const app = makeLegacyApp();
-    const store = mockStore(app, { "index.html": "<html>hello</html>" });
-
-    const result = executeAppFileRead(
-      { app_id: app.id, path: "index.html" },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("<html>hello</html>");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// executeAppFileEdit
-// ---------------------------------------------------------------------------
-
-describe("executeAppFileEdit", () => {
-  test("resolves plain path to src/ for multifile app", () => {
-    const files = { "src/main.tsx": "const x = 1;" };
-    const app = makeMultifileApp();
-    const store = mockStore(app, files);
-
-    const result = executeAppFileEdit(
-      {
-        app_id: app.id,
-        path: "main.tsx",
-        old_string: "const x = 1;",
-        new_string: "const x = 2;",
-      },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(files["src/main.tsx"]).toBe("const x = 2;");
-  });
-
-  test("does not modify path for legacy app", () => {
-    const files = { "index.html": "<p>old</p>" };
-    const app = makeLegacyApp();
-    const store = mockStore(app, files);
-
-    const result = executeAppFileEdit(
-      {
-        app_id: app.id,
-        path: "index.html",
-        old_string: "<p>old</p>",
-        new_string: "<p>new</p>",
-      },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(files["index.html"]).toBe("<p>new</p>");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// executeAppFileList
-// ---------------------------------------------------------------------------
-
-describe("executeAppFileList", () => {
-  test("returns clean file paths and separate buildOutput for multifile app", () => {
-    const app = makeMultifileApp();
-    const store = mockStore(app, {
-      "src/main.tsx": "",
-      "src/components/Header.tsx": "",
-      "dist/index.html": "",
-    });
-
-    const result = executeAppFileList({ app_id: app.id }, store);
-    const parsed = JSON.parse(result.content) as {
-      files: string[];
-      buildOutput: string[];
-    };
-
-    // File paths must be clean — no annotations appended
-    expect(parsed.files).toContain("src/main.tsx");
-    expect(parsed.files).toContain("src/components/Header.tsx");
-    expect(parsed.files).toContain("dist/index.html");
-    expect(
-      parsed.files.every((f: string) => !f.includes("[build output]")),
-    ).toBe(true);
-
-    // Build output files listed separately
-    expect(parsed.buildOutput).toEqual(["dist/index.html"]);
-  });
-
-  test("does not annotate files for legacy app", () => {
-    const app = makeLegacyApp();
-    const store = mockStore(app, {
-      "index.html": "",
-      "styles.css": "",
-    });
-
-    const result = executeAppFileList({ app_id: app.id }, store);
-    const parsed = JSON.parse(result.content) as string[];
-
-    expect(parsed).toContain("index.html");
-    expect(parsed).toContain("styles.css");
-    expect(parsed.every((f: string) => !f.includes("[build output]"))).toBe(
-      true,
-    );
-  });
-});
-
 // ---------------------------------------------------------------------------
 // executeAppCreate
 // ---------------------------------------------------------------------------

package/src/__tests__/app-git-history.test.ts

@@ -14,7 +14,7 @@ mock.module("../util/platform.js", () => ({
 }));
 
 // Re-import after mocking so modules use our temp dir
-const { createApp, updateApp, getAppsDir } =
+const { createApp, updateApp, getAppDirPath } =
   await import("../memory/app-store.js");
 const {
   getAppHistory,
@@ -147,7 +147,7 @@ describe("App Git History", () => {
 
     // Current file should show new content
     const currentContent = readFileSync(
-      join(getAppsDir(), app.id, "index.html"),
+      join(getAppDirPath(app.id), "index.html"),
       "utf-8",
     );
     expect(currentContent).toContain("version two");
@@ -169,7 +169,7 @@ describe("App Git History", () => {
 
     // Verify current content is "new content"
     let current = readFileSync(
-      join(getAppsDir(), app.id, "index.html"),
+      join(getAppDirPath(app.id), "index.html"),
       "utf-8",
     );
     expect(current).toContain("new content");
@@ -178,7 +178,7 @@ describe("App Git History", () => {
     await restoreAppVersion(app.id, originalHash);
 
     // Verify content is restored
-    current = readFileSync(join(getAppsDir(), app.id, "index.html"), "utf-8");
+    current = readFileSync(join(getAppDirPath(app.id), "index.html"), "utf-8");
     expect(current).toContain("original content");
 
     // Verify a restore commit was created

package/src/__tests__/app-routes-csp.test.ts

@@ -37,6 +37,7 @@ const apps = new Map<string, typeof legacyApp | typeof multifileApp>([
 mock.module("../memory/app-store.js", () => ({
   getApp: (id: string) => apps.get(id) ?? null,
   getAppsDir: () => "/fake/apps",
+  getAppDirPath: (appId: string) => `/fake/apps/${appId}`,
   isMultifileApp: (app: Record<string, unknown>) => app.formatVersion === 2,
 }));