npm - os-dpt - Versions diffs - 0.2.0 → 0.2.1 - Mend

os-dpt 0.2.0 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +54 -23
package/package.json +1 -1
package/server/dist/client/assets/{highlighted-body-OFNGDK62-DVn0rkjL.js → highlighted-body-OFNGDK62-DVsDtUg7.js} +1 -1
package/server/dist/client/assets/index-BbfkzqpQ.css +1 -0
package/server/dist/client/assets/index-BejCAhC3.js +251 -0
package/server/dist/client/index.html +2 -2
package/server/dist/index.mjs +247 -31
package/server/dist/client/assets/index-4qMZFL9L.js +0 -251
package/server/dist/client/assets/index-DweMyov5.css +0 -1

package/server/dist/client/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/dpt.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Data Profile Tool</title>
-    <script type="module" crossorigin src="/assets/index-4qMZFL9L.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DweMyov5.css">
+    <script type="module" crossorigin src="/assets/index-BejCAhC3.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BbfkzqpQ.css">
   </head>
   <body>
     <div id="root"></div>

package/server/dist/index.mjs CHANGED Viewed

@@ -9,7 +9,7 @@ for (const envPath of [".env", "../.env"]) {
 // server/index.ts
 import { pathToFileURL } from "node:url";
 import { serve } from "@hono/node-server";
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 import { HTTPException as HTTPException4 } from "hono/http-exception";
 // server/api/ai-providers.ts
@@ -221,6 +221,7 @@ var CONTEXT_DOC_NAMES = CONTEXT_DOCS.map((d) => d.name);
 // server/workspace.ts
 var exec = promisify(execFile);
 var WORKSHEETS_DIR = "worksheets";
+var DASHBOARDS_DIR = "dashboards";
 var CONTEXT_DIR = "context";
 var CONTEXT_BY_SOURCE = "by-source";
 var OSDPT_DIR = ".os-dpt";
@@ -244,6 +245,7 @@ function resolveWorkspace(argv) {
 async function initWorkspace(argv = process.argv.slice(2)) {
   const root = resolveWorkspace(argv);
   await fs4.mkdir(path4.join(root, WORKSHEETS_DIR), { recursive: true });
+  await fs4.mkdir(path4.join(root, DASHBOARDS_DIR), { recursive: true });
   await fs4.mkdir(path4.join(root, DRAFTS_DIR), { recursive: true });
   await fs4.mkdir(path4.join(root, CHATS_DIR), { recursive: true });
   await fs4.mkdir(path4.join(root, CONTEXT_DIR), { recursive: true });
@@ -300,6 +302,8 @@ function workspacePath(...segments) {
 var paths = {
   worksheets: () => workspacePath(WORKSHEETS_DIR),
   worksheet: (slug) => workspacePath(WORKSHEETS_DIR, `${slug}.sql`),
+  dashboards: () => workspacePath(DASHBOARDS_DIR),
+  dashboard: (slug) => workspacePath(DASHBOARDS_DIR, `${slug}.json`),
   drafts: () => workspacePath(DRAFTS_DIR),
   draft: (slug) => workspacePath(DRAFTS_DIR, `${slug}.sql`),
   schemas: () => workspacePath(SCHEMAS_DIR),
@@ -634,6 +638,7 @@ async function introspect(pool) {
 // server/db/postgres.ts
 import pg from "pg";
+pg.types.setTypeParser(pg.types.builtins.DATE, (value) => value);
 function clientConfig(conn, password) {
   return {
     host: conn.host,
@@ -1183,9 +1188,9 @@ import { promises as fs9 } from "node:fs";
 import path8 from "node:path";
 // server/lib/slug.ts
-function slugify(name) {
+function slugify(name, fallback = "worksheet") {
   const base = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return base || "worksheet";
+  return base || fallback;
 }
 function dedupeSlug(slug, existing) {
   if (!existing.has(slug)) return slug;
@@ -1969,6 +1974,14 @@ import { Hono as Hono8 } from "hono";
 import { streamSSE } from "hono/streaming";
 // shared/agent.ts
+var CHART_TYPES = [
+  "bar",
+  "stacked-bar",
+  "line",
+  "area",
+  "pie",
+  "funnel"
+];
 function emptyTotals() {
   return {
     inputTokens: 0,
@@ -2080,16 +2093,17 @@ function buildSystemPrompt(session) {
 }
 function buildQuickEditPrompt(session) {
   const { worksheetSlug, connectionId } = session.meta;
+  const noun = worksheetSlug ? "worksheet" : "query";
   const lines = [
-    "You are os-dpt's inline SQL-editing agent. The user prompts you from a small floating box inside their SQL editor. Your ONLY deliverable is SQL staged into their worksheet via write_sql \u2014 the user never reads chat output in this mode, they watch the editor update.",
+    worksheetSlug ? "You are os-dpt's inline SQL-editing agent. The user prompts you from a small floating box inside their SQL editor. Your ONLY deliverable is SQL staged into their worksheet via write_sql \u2014 the user never reads chat output in this mode, they watch the editor update." : "You are os-dpt's inline SQL-editing agent. The user is editing a standalone SQL query (e.g. a saved chart's source query). Your ONLY deliverable is SQL staged back into their editor via write_sql \u2014 the user never reads chat output in this mode, they watch the editor update.",
     "",
     "Output rules (hard requirements):",
     "- Emit NO prose. No preamble, no explanation, no closing summary \u2014 no text blocks at all.",
     "- Anything worth flagging (an assumption you made, a caveat, a data-quality quirk) goes in a SQL comment inside the query itself.",
-    "- Always finish by calling write_sql with the COMPLETE worksheet contents (drafts are overwrites, not patches), then end the turn.",
+    `- Always finish by calling write_sql with the COMPLETE ${noun} contents (writes are overwrites, not patches), then end the turn.`,
     "",
     "Method:",
-    "- Each user message ends with the worksheet's current contents. Treat the request as an edit to that SQL unless it clearly asks for something new; preserve parts of the worksheet the request doesn't touch.",
+    `- Each user message ends with the ${noun}'s current contents. Treat the request as an edit to that SQL unless it clearly asks for something new; preserve parts of the ${noun} the request doesn't touch.`,
     "- Check get_context first when the request depends on schema, business terms, or conventions you have not verified this session; call get_schema when tables or columns are uncertain. Do not guess names.",
     "- Verify your SQL with run_sql before staging it. If it errors, fix and re-run until it works. Treat verification as read-only \u2014 SELECT only; never run DDL or DML in this mode.",
     "- If no connection is bound or verification is impossible, stage your best SQL with a leading '-- not verified' comment instead of stopping.",
@@ -2531,7 +2545,7 @@ var askUserQuestionTool = {
 // server/agent/tools/write_sql.ts
 var writeSqlTool = {
   name: "write_sql",
-  description: "Stage SQL into the editor. Writes to the worksheet's draft (autosave channel), so the user sees the SQL appear in the editor without losing their saved version until they hit Cmd+S. Defaults to the chat's bound worksheet. Pass the COMPLETE worksheet contents \u2014 drafts are overwrites, not patches.",
+  description: "Stage SQL into the editor. Writes to the worksheet's draft (autosave channel), so the user sees the SQL appear in the editor without losing their saved version until they hit Cmd+S. Defaults to the chat's bound worksheet. Pass the COMPLETE worksheet contents \u2014 drafts are overwrites, not patches. When no worksheet is bound, the SQL streams straight back to the editor that launched this session.",
   input_schema: {
     type: "object",
     required: ["sql"],
@@ -2557,6 +2571,14 @@ var writeSqlTool = {
     }
     const slug = input.worksheet_slug ?? ctx.session.meta.worksheetSlug;
     if (!slug) {
+      if (ctx.session.meta.mode === "quick-edit") {
+        return {
+          toolResult: `Staged ${input.sql.length} bytes back to the editor.`,
+          isError: false,
+          uiSummary: `Staged ${input.sql.length} chars into the editor`,
+          events: [{ type: "sql_written", worksheetSlug: null, sql: input.sql }]
+        };
+      }
       return {
         toolResult: "No worksheet bound. Ask the user which worksheet to write to, or set worksheet_slug.",
         isError: true,
@@ -2702,7 +2724,6 @@ var runSqlTool = {
 };
 // server/agent/tools/render_chart.ts
-var CHART_TYPES = ["bar", "stacked-bar", "line", "area", "pie", "funnel"];
 var MAX_ROWS2 = 500;
 var MAX_SERIES = 8;
 function parseSeries(raw) {
@@ -2920,7 +2941,10 @@ async function runTurn(opts) {
   }
   const system = buildSystemPrompt(session);
   const tools = anthropicToolDefs({
-    worksheetBound: !!session.meta.worksheetSlug,
+    // Quick-edit always keeps write_sql — it's the mode's only deliverable.
+    // Without a worksheet bound the tool skips the draft write and streams
+    // the SQL back to the launching editor via the sql_written event.
+    worksheetBound: !!session.meta.worksheetSlug || session.meta.mode === "quick-edit",
     mode: session.meta.mode
   });
   for (let step = 0; step < MAX_STEPS; step += 1) {
@@ -3396,10 +3420,201 @@ app7.put("/:name", async (c) => {
 });
 var context_default = app7;
+// server/api/dashboards.ts
+import { Hono as Hono10 } from "hono";
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { promises as fs18 } from "node:fs";
+var app8 = new Hono10();
+var MAX_NAME_LEN2 = 80;
+var MAX_TITLE_LEN = 120;
+async function readDashboard(slug) {
+  try {
+    const raw = await fs18.readFile(paths.dashboard(slug), "utf8");
+    const parsed = JSON.parse(raw);
+    return normalize2(slug, parsed);
+  } catch {
+    return null;
+  }
+}
+function normalize2(slug, d) {
+  return {
+    slug,
+    name: typeof d.name === "string" && d.name.trim() !== "" ? d.name : slug,
+    createdAt: d.createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    updatedAt: d.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    charts: (Array.isArray(d.charts) ? d.charts : []).flatMap((chart, i) => {
+      const parsed = parseChart(chart);
+      if (typeof parsed === "string") return [];
+      const c = chart;
+      return [
+        {
+          ...parsed,
+          id: typeof c.id === "string" && c.id !== "" ? c.id : deriveChartId(slug, i, chart),
+          position: typeof c.position === "number" ? c.position : i
+        }
+      ];
+    })
+  };
+}
+function deriveChartId(slug, index, chart) {
+  const hash = createHash2("sha256").update(`${slug}
+${index}
+${JSON.stringify(chart)}`).digest("hex");
+  return `gen-${hash.slice(0, 12)}`;
+}
+async function persist2(dashboard) {
+  dashboard.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeAtomic(paths.dashboard(dashboard.slug), JSON.stringify(dashboard, null, 2));
+  return dashboard;
+}
+async function listSlugs() {
+  const entries = await fs18.readdir(paths.dashboards()).catch(() => []);
+  return entries.filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5));
+}
+var mutationTails = /* @__PURE__ */ new Map();
+function withDashboardLock(slug, fn) {
+  const prev = mutationTails.get(slug) ?? Promise.resolve();
+  const result = prev.then(fn);
+  const tail = result.then(
+    () => void 0,
+    () => void 0
+  );
+  mutationTails.set(slug, tail);
+  void tail.then(() => {
+    if (mutationTails.get(slug) === tail) mutationTails.delete(slug);
+  });
+  return result;
+}
+function parseChart(raw) {
+  if (!raw || typeof raw !== "object") return "chart must be an object";
+  const c = raw;
+  if (!CHART_TYPES.includes(c.type)) {
+    return `type must be one of: ${CHART_TYPES.join(", ")}`;
+  }
+  if (typeof c.x !== "string" || c.x.trim() === "") return "x must be a non-empty string";
+  if (typeof c.sql !== "string" || c.sql.trim() === "") return "sql must be a non-empty string";
+  if (!Array.isArray(c.series) || c.series.length === 0) {
+    return "series must be a non-empty array of { key, label? }";
+  }
+  const series = [];
+  for (const item of c.series) {
+    if (!item || typeof item !== "object" || typeof item.key !== "string") {
+      return "each series must be an object with a string `key`";
+    }
+    const s = item;
+    series.push(typeof s.label === "string" && s.label !== "" ? { key: s.key, label: s.label } : { key: s.key });
+  }
+  const title = typeof c.title === "string" && c.title.trim() !== "" ? c.title.trim() : "Untitled chart";
+  const connectionId = typeof c.connectionId === "string" && c.connectionId !== "" ? c.connectionId : null;
+  return {
+    title: title.length > MAX_TITLE_LEN ? title.slice(0, MAX_TITLE_LEN) : title,
+    type: c.type,
+    x: c.x,
+    series,
+    sql: c.sql,
+    connectionId
+  };
+}
+app8.get("/", async (c) => {
+  const slugs = await listSlugs();
+  const metas = [];
+  for (const slug of slugs) {
+    const d = await readDashboard(slug);
+    if (!d) continue;
+    metas.push({ slug, name: d.name, updatedAt: d.updatedAt, chartCount: d.charts.length });
+  }
+  metas.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return c.json({ dashboards: metas });
+});
+app8.post("/", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const raw = (body.name ?? "").trim();
+  const name = raw === "" ? "Dashboard" : raw.length > MAX_NAME_LEN2 ? raw.slice(0, MAX_NAME_LEN2) : raw;
+  const existing = new Set(await listSlugs());
+  const slug = dedupeSlug(slugify(name, "dashboard"), existing);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const dashboard = { slug, name, createdAt: now, updatedAt: now, charts: [] };
+  await writeAtomic(paths.dashboard(slug), JSON.stringify(dashboard, null, 2));
+  return c.json(dashboard, 201);
+});
+app8.get("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const dashboard = await readDashboard(slug);
+  if (!dashboard) return c.json({ error: "not_found" }, 404);
+  return c.json(dashboard);
+});
+app8.patch("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const body = await c.req.json().catch(() => ({}));
+  const raw = (body.name ?? "").trim();
+  if (!raw) return c.json({ error: "empty_name" }, 400);
+  return withDashboardLock(slug, async () => {
+    const dashboard = await readDashboard(slug);
+    if (!dashboard) return c.json({ error: "not_found" }, 404);
+    dashboard.name = raw.length > MAX_NAME_LEN2 ? raw.slice(0, MAX_NAME_LEN2) : raw;
+    return c.json(await persist2(dashboard));
+  });
+});
+app8.delete("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  return withDashboardLock(slug, async () => {
+    await fs18.rm(paths.dashboard(slug), { force: true });
+    return c.json({ ok: true });
+  });
+});
+app8.post("/:slug/charts", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const body = await c.req.json().catch(() => null);
+  const parsed = parseChart(body);
+  if (typeof parsed === "string") return c.json({ error: parsed }, 400);
+  return withDashboardLock(slug, async () => {
+    const dashboard = await readDashboard(slug);
+    if (!dashboard) return c.json({ error: "not_found" }, 404);
+    const position = dashboard.charts.reduce((max, ch) => Math.max(max, ch.position), -1) + 1;
+    const chart = { ...parsed, id: randomUUID(), position };
+    dashboard.charts.push(chart);
+    return c.json(await persist2(dashboard));
+  });
+});
+app8.put("/:slug/charts/:chartId", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const chartId = c.req.param("chartId");
+  const body = await c.req.json().catch(() => ({}));
+  return withDashboardLock(slug, async () => {
+    const dashboard = await readDashboard(slug);
+    if (!dashboard) return c.json({ error: "not_found" }, 404);
+    const chart = dashboard.charts.find((ch) => ch.id === chartId);
+    if (!chart) return c.json({ error: "not_found" }, 404);
+    const parsed = parseChart({ ...chart, ...body });
+    if (typeof parsed === "string") return c.json({ error: parsed }, 400);
+    Object.assign(chart, parsed);
+    return c.json(await persist2(dashboard));
+  });
+});
+app8.delete("/:slug/charts/:chartId", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const chartId = c.req.param("chartId");
+  return withDashboardLock(slug, async () => {
+    const dashboard = await readDashboard(slug);
+    if (!dashboard) return c.json({ error: "not_found" }, 404);
+    const before = dashboard.charts.length;
+    dashboard.charts = dashboard.charts.filter((ch) => ch.id !== chartId);
+    if (dashboard.charts.length === before) return c.json({ error: "not_found" }, 404);
+    return c.json(await persist2(dashboard));
+  });
+});
+var dashboards_default = app8;
 // server/history/watcher.ts
-import { promises as fs18, watch } from "node:fs";
+import { promises as fs19, watch } from "node:fs";
 import path10 from "node:path";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 var SLUG_RE2 = /^[a-z0-9][a-z0-9_-]*$/i;
 var watcher = null;
 function startWorksheetsWatcher() {
@@ -3418,11 +3633,11 @@ function startWorksheetsWatcher() {
 async function handleEvent(slug, filePath2) {
   let content;
   try {
-    content = await fs18.readFile(filePath2, "utf8");
+    content = await fs19.readFile(filePath2, "utf8");
   } catch {
     return;
   }
-  const sha = createHash2("sha256").update(content, "utf8").digest("hex");
+  const sha = createHash3("sha256").update(content, "utf8").digest("hex");
   if (isRecentWrite(slug, sha)) return;
   recordHistory({ worksheet: slug, source: "external", content });
 }
@@ -3464,10 +3679,10 @@ function contentType(file) {
 function cacheControl(urlPath) {
   return urlPath.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache";
 }
-function serveClient(app8, clientDir = defaultClientDir()) {
+function serveClient(app9, clientDir = defaultClientDir()) {
   if (!existsSync(path11.join(clientDir, "index.html"))) return false;
   const indexHtml = path11.join(clientDir, "index.html");
-  app8.get("*", async (c) => {
+  app9.get("*", async (c) => {
     if (c.req.path.startsWith("/api")) return c.notFound();
     const rel = decodeURIComponent(c.req.path).replace(/^\/+/, "");
     const candidate = path11.resolve(clientDir, rel);
@@ -3511,11 +3726,11 @@ function openBrowser(url) {
 // server/index.ts
 var DEFAULT_PORT = 3756;
-function listen(app8, port) {
+function listen(app9, port) {
   return new Promise((resolve, reject) => {
     let retried = false;
     const attempt = (p) => {
-      const server = serve({ fetch: app8.fetch, port: p, hostname: "127.0.0.1" });
+      const server = serve({ fetch: app9.fetch, port: p, hostname: "127.0.0.1" });
       server.once("listening", () => resolve(server));
       server.once("error", (err) => {
         if (err.code === "EADDRINUSE" && !retried) {
@@ -3535,25 +3750,26 @@ async function startServer(argv = process.argv.slice(2)) {
   openHistoryDb();
   startWorksheetsWatcher();
   void autoConnectAll(workspace);
-  const app8 = new Hono10();
-  app8.get("/api/health", (c) => c.json({ ok: true, workspace }));
-  app8.route("/api/connections", connectionsRouter(workspace));
-  app8.route("/api/ai-providers", aiProvidersRouter(workspace));
-  app8.route("/api/worksheets", worksheets_default);
-  app8.route("/api/drafts", drafts_default);
-  app8.route("/api/session", session_default);
-  app8.route("/api/schema", schema_default);
-  app8.route("/api/history", history_default);
-  app8.route("/api/agent", agent_default);
-  app8.route("/api/context", context_default);
-  app8.onError((err, c) => {
+  const app9 = new Hono11();
+  app9.get("/api/health", (c) => c.json({ ok: true, workspace }));
+  app9.route("/api/connections", connectionsRouter(workspace));
+  app9.route("/api/ai-providers", aiProvidersRouter(workspace));
+  app9.route("/api/worksheets", worksheets_default);
+  app9.route("/api/drafts", drafts_default);
+  app9.route("/api/session", session_default);
+  app9.route("/api/schema", schema_default);
+  app9.route("/api/history", history_default);
+  app9.route("/api/agent", agent_default);
+  app9.route("/api/context", context_default);
+  app9.route("/api/dashboards", dashboards_default);
+  app9.onError((err, c) => {
     if (err instanceof HTTPException4) return err.getResponse();
     console.error("[os-dpt]", err);
     return c.json({ error: err.message }, 500);
   });
-  serveClient(app8);
+  serveClient(app9);
   const preferredPort = Number(process.env.PORT ?? DEFAULT_PORT);
-  const server = await listen(app8, preferredPort);
+  const server = await listen(app9, preferredPort);
   const addr = server.address();
   const port = typeof addr === "object" && addr ? addr.port : preferredPort;
   const url = `http://127.0.0.1:${port}`;