yamchart 0.4.19 → 0.5.1

package/dist/dist-ZRRM3OWF.js

@@ -0,0 +1,651 @@
+import "./chunk-DGUM43GV.js";
+
+// ../../packages/advisor/dist/dbt/knowledge.js
+import { readFile } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var KNOWLEDGE_DIR = join(__dirname, "..", "knowledge");
+var KNOWLEDGE_TOPICS = [
+  "materializations",
+  "incremental",
+  "macros",
+  "testing",
+  "naming",
+  "performance"
+];
+async function loadKnowledge(topic) {
+  if (!KNOWLEDGE_TOPICS.includes(topic)) {
+    return `Unknown topic: "${topic}". Available topics: ${KNOWLEDGE_TOPICS.join(", ")}`;
+  }
+  const filePath = join(KNOWLEDGE_DIR, `${topic}.md`);
+  return readFile(filePath, "utf-8");
+}
+function getKnowledgeOverview() {
+  return `You have access to a dbt knowledge base via the get_knowledge tool. Available topics:
+${KNOWLEDGE_TOPICS.map((t) => `- ${t}`).join("\n")}
+
+Use get_knowledge when you need specifics on materializations, incremental strategies, Jinja macros, testing, naming conventions, or performance optimization.`;
+}
+
+// ../../packages/advisor/dist/dbt/project.js
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2, basename, relative, dirname as dirname2 } from "path";
+import fg from "fast-glob";
+import { parse as parseYaml } from "yaml";
+async function getModelPaths(projectPath) {
+  const content = await readFile2(join2(projectPath, "dbt_project.yml"), "utf-8");
+  const parsed = parseYaml(content);
+  return parsed["model-paths"] ?? parsed.model_paths ?? ["models"];
+}
+function extractMaterialization(sql) {
+  const match = sql.match(/materialized\s*=\s*['"](\w+)['"]/);
+  return match?.[1] ?? "view";
+}
+function detectLayer(relativePath) {
+  const parts = relativePath.split("/");
+  return parts[0] ?? "unknown";
+}
+function detectPrefix(models) {
+  const prefixesByLayer = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const underscoreIdx = model.name.indexOf("_");
+    if (underscoreIdx === -1)
+      continue;
+    const prefix = model.name.slice(0, underscoreIdx + 1);
+    if (!prefixesByLayer.has(model.layer)) {
+      prefixesByLayer.set(model.layer, /* @__PURE__ */ new Map());
+    }
+    const counts = prefixesByLayer.get(model.layer);
+    counts.set(prefix, (counts.get(prefix) ?? 0) + 1);
+  }
+  const result = {};
+  for (const [layer, counts] of prefixesByLayer) {
+    let maxCount = 0;
+    let maxPrefix = "";
+    for (const [prefix, count] of counts) {
+      if (count > maxCount) {
+        maxCount = count;
+        maxPrefix = prefix;
+      }
+    }
+    if (maxPrefix && maxCount >= 2) {
+      result[layer] = maxPrefix;
+    }
+  }
+  return result;
+}
+function detectMaterializations(models) {
+  const matByLayer = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    if (!matByLayer.has(model.layer)) {
+      matByLayer.set(model.layer, /* @__PURE__ */ new Map());
+    }
+    const counts = matByLayer.get(model.layer);
+    counts.set(model.materialization, (counts.get(model.materialization) ?? 0) + 1);
+  }
+  const result = {};
+  for (const [layer, counts] of matByLayer) {
+    let maxCount = 0;
+    let maxMat = "";
+    for (const [mat, count] of counts) {
+      if (count > maxCount) {
+        maxCount = count;
+        maxMat = mat;
+      }
+    }
+    if (maxMat)
+      result[layer] = maxMat;
+  }
+  return result;
+}
+async function detectSchemaYmlPattern(projectPath, modelPaths) {
+  const ymlFiles = [];
+  for (const mp of modelPaths) {
+    const pattern = join2(projectPath, mp, "**/*.yml");
+    const files = await fg(pattern, { ignore: ["**/node_modules/**"] });
+    ymlFiles.push(...files);
+  }
+  if (ymlFiles.length === 0)
+    return "per-folder";
+  if (ymlFiles.length === 1)
+    return "single-file";
+  const dirs = new Set(ymlFiles.map((f) => dirname2(f)));
+  return dirs.size > 1 ? "per-folder" : "single-file";
+}
+async function detectConventions(projectPath) {
+  const modelPaths = await getModelPaths(projectPath);
+  const models = await listDbtModels(projectPath);
+  const folders = [...new Set(models.map((m) => m.layer))].filter((l) => l !== "unknown");
+  return {
+    folderStructure: folders,
+    namingPrefixes: detectPrefix(models),
+    commonMaterializations: detectMaterializations(models),
+    schemaYmlPattern: await detectSchemaYmlPattern(projectPath, modelPaths),
+    testPatterns: []
+  };
+}
+async function listDbtModels(projectPath) {
+  const modelPaths = await getModelPaths(projectPath);
+  const models = [];
+  for (const mp of modelPaths) {
+    const pattern = join2(projectPath, mp, "**/*.sql");
+    const files = await fg(pattern, { ignore: ["**/node_modules/**"] });
+    for (const file of files) {
+      const relPath = relative(join2(projectPath, mp), file);
+      const name = basename(file, ".sql");
+      const sql = await readFile2(file, "utf-8");
+      const materialization = extractMaterialization(sql);
+      const layer = detectLayer(relPath);
+      const folder = dirname2(relPath);
+      models.push({ name, path: relPath, layer, materialization, folder });
+    }
+  }
+  return models;
+}
+async function readDbtModel(projectPath, modelName) {
+  const models = await listDbtModels(projectPath);
+  const model = models.find((m) => m.name === modelName);
+  if (!model)
+    return null;
+  const modelPaths = await getModelPaths(projectPath);
+  for (const mp of modelPaths) {
+    const fullPath = join2(projectPath, mp, model.path);
+    try {
+      return await readFile2(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// ../../packages/advisor/dist/tools.js
+var TOOL_DEFINITIONS = [
+  // Read-only tools
+  {
+    name: "list_yamchart_models",
+    description: "List all yamchart SQL models with names, descriptions, parameters, and return columns",
+    parameters: { type: "object", properties: {}, required: [] }
+  },
+  {
+    name: "list_charts",
+    description: "List all yamchart charts showing which models they reference and their chart type",
+    parameters: { type: "object", properties: {}, required: [] }
+  },
+  {
+    name: "get_catalog",
+    description: "Get the dbt catalog (.yamchart/catalog.md) with upstream table schemas and column metadata",
+    parameters: { type: "object", properties: {}, required: [] }
+  },
+  {
+    name: "introspect_warehouse",
+    description: "Query the live warehouse. Use for discovering raw tables not yet modeled in dbt.",
+    parameters: {
+      type: "object",
+      properties: {
+        sql: { type: "string", description: "SQL query to execute (e.g. SHOW TABLES, SELECT * FROM information_schema.columns)" }
+      },
+      required: ["sql"]
+    }
+  },
+  {
+    name: "sample_data",
+    description: "Preview rows from a table in the warehouse",
+    parameters: {
+      type: "object",
+      properties: {
+        table: { type: "string", description: "Table name (can be schema-qualified)" },
+        limit: { type: "number", description: "Number of rows to return (default: 5)" }
+      },
+      required: ["table"]
+    }
+  },
+  {
+    name: "read_dbt_model",
+    description: "Read the full SQL source of an existing dbt model",
+    parameters: {
+      type: "object",
+      properties: {
+        model_name: { type: "string", description: "Name of the dbt model to read" }
+      },
+      required: ["model_name"]
+    }
+  },
+  {
+    name: "list_dbt_models",
+    description: "List all dbt models with their layer (staging/intermediate/marts), materialization, and folder",
+    parameters: { type: "object", properties: {}, required: [] }
+  },
+  {
+    name: "get_knowledge",
+    description: "Look up dbt reference documentation on a topic: materializations, incremental, macros, testing, naming, performance",
+    parameters: {
+      type: "object",
+      properties: {
+        topic: { type: "string", description: "Topic name: materializations, incremental, macros, testing, naming, performance" }
+      },
+      required: ["topic"]
+    }
+  },
+  // Action tools
+  {
+    name: "propose_model",
+    description: "Propose a new dbt model. Call this when you have a suggestion to present to the user.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Model name (snake_case)" },
+        description: { type: "string", description: "One-line description of what this model does" },
+        sql: { type: "string", description: "Full SQL for the model (may include Jinja)" },
+        layer: { type: "string", description: "dbt layer: staging, intermediate, or marts" },
+        materialization: { type: "string", description: "Materialization: view, table, or incremental" },
+        explanation: { type: "string", description: "Why this model is useful (2-3 sentences)" },
+        subfolder: { type: "string", description: 'Optional subfolder within the layer (e.g. "stripe", "core")' },
+        columns: {
+          type: "array",
+          description: "Column definitions for schema.yml",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              description: { type: "string" },
+              tests: { type: "array", items: { type: "string" } }
+            },
+            required: ["name"]
+          }
+        }
+      },
+      required: ["name", "description", "sql", "layer", "materialization", "explanation"]
+    }
+  },
+  {
+    name: "write_dbt_model",
+    description: "Write a proposed dbt model SQL file to the dbt project. Only call after proposing and user confirmation.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Model name (must match a previous proposal)" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "update_schema_yml",
+    description: "Add or update the model entry in the appropriate schema.yml file. Only call after writing the model.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Model name (must match a written model)" }
+      },
+      required: ["name"]
+    }
+  }
+];
+async function executeToolCall(context, toolName, input) {
+  switch (toolName) {
+    case "list_yamchart_models":
+      return JSON.stringify(context.yamchart.models.map((m) => ({
+        name: m.name,
+        description: m.description,
+        params: m.params,
+        returns: m.returns
+      })));
+    case "list_charts":
+      return JSON.stringify(context.yamchart.charts.map((c) => ({
+        name: c.name,
+        title: c.title,
+        model: c.model,
+        type: c.type
+      })));
+    case "get_catalog":
+      return context.yamchart.catalog ?? "No dbt catalog found. Run `yamchart sync-dbt` to create one.";
+    case "introspect_warehouse": {
+      if (!context.warehouse) {
+        return "Warehouse introspection not available. No database connection configured.";
+      }
+      const sql = input.sql;
+      try {
+        const result = await context.warehouse.executeSql(sql);
+        return JSON.stringify(result);
+      } catch (err) {
+        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    case "sample_data": {
+      if (!context.warehouse) {
+        return "Warehouse not available. No database connection configured.";
+      }
+      const table = input.table;
+      const limit = input.limit ?? 5;
+      try {
+        const result = await context.warehouse.executeSql(`SELECT * FROM ${table} LIMIT ${limit}`);
+        return JSON.stringify(result);
+      } catch (err) {
+        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    case "read_dbt_model": {
+      const modelName = input.model_name;
+      const sql = await readDbtModel(context.dbt.projectPath, modelName);
+      if (!sql) {
+        return JSON.stringify({ error: `Model not found: ${modelName}` });
+      }
+      return JSON.stringify({ name: modelName, sql });
+    }
+    case "list_dbt_models":
+      return JSON.stringify(context.dbt.models.map((m) => ({
+        name: m.name,
+        path: m.path,
+        layer: m.layer,
+        materialization: m.materialization,
+        folder: m.folder
+      })));
+    case "get_knowledge": {
+      const topic = input.topic;
+      return loadKnowledge(topic);
+    }
+    case "propose_model":
+      return JSON.stringify({
+        status: "proposed",
+        name: input.name,
+        description: input.description,
+        sql: input.sql,
+        layer: input.layer,
+        materialization: input.materialization,
+        explanation: input.explanation,
+        subfolder: input.subfolder,
+        columns: input.columns
+      });
+    case "write_dbt_model":
+      return JSON.stringify({
+        status: "pending_confirmation",
+        name: input.name,
+        message: "Model write requested. Waiting for user confirmation."
+      });
+    case "update_schema_yml":
+      return JSON.stringify({
+        status: "pending_confirmation",
+        name: input.name,
+        message: "Schema.yml update requested. Waiting for user confirmation."
+      });
+    default:
+      return JSON.stringify({ error: `Unknown tool: ${toolName}` });
+  }
+}
+
+// ../../packages/advisor/dist/agent.js
+var SYSTEM_PROMPT = `You are a dbt advisor for yamchart projects. You analyze the BI layer (yamchart models, charts, dashboards) and the data engineering layer (dbt models, warehouse tables) to suggest improvements to dbt models.
+
+Think like a senior data engineer. Your goals:
+- Understand what the BI layer needs (charts, filters, drill-downs, date ranges)
+- Identify gaps in the dbt project (missing models, incomplete staging, opportunities for pre-aggregation)
+- Suggest new dbt models that serve the BI layer better
+- Follow the project's existing conventions (folder structure, naming, materializations)
+
+When proposing models:
+- Match the project's naming conventions (detect and follow existing prefixes like stg_, fct_, dim_)
+- Place models in the correct layer and folder
+- Choose appropriate materializations
+- Include column descriptions and tests in proposals
+- Explain WHY the model helps, not just WHAT it does
+- Use ref() and source() macros correctly
+
+When in audit mode:
+- Evaluate: coverage gaps, convention violations, materialization mismatches, missing tests
+- Rank suggestions by impact
+- Be concise \u2014 focus on actionable improvements
+
+${getKnowledgeOverview()}
+
+When you have a suggestion, call propose_model with the full SQL and metadata. Do NOT call write_dbt_model or update_schema_yml directly \u2014 the user will be prompted to confirm before writing.`;
+var MAX_TOOL_ROUNDS = 15;
+var AdvisorAgent = class {
+  provider;
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async run(context, userMessages) {
+    const proposals = [];
+    const messages = [...userMessages];
+    const systemPrompt = this.buildSystemPrompt(context);
+    for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+      const response = await this.provider.chat({
+        system: systemPrompt,
+        messages,
+        tools: TOOL_DEFINITIONS
+      });
+      const textBlocks = response.content.filter((b) => b.type === "text");
+      const toolUseBlocks = response.content.filter((b) => b.type === "tool_use");
+      if (toolUseBlocks.length === 0) {
+        const responseText = textBlocks.map((b) => b.text).join("\n");
+        return { response: responseText, proposals, messages };
+      }
+      messages.push({ role: "assistant", content: response.content });
+      const toolResults = [];
+      for (const toolUse of toolUseBlocks) {
+        const result = await executeToolCall(context, toolUse.name, toolUse.input);
+        if (toolUse.name === "propose_model") {
+          const parsed = JSON.parse(result);
+          proposals.push({
+            name: parsed.name,
+            description: parsed.description,
+            sql: toolUse.input.sql,
+            layer: toolUse.input.layer,
+            materialization: toolUse.input.materialization,
+            explanation: toolUse.input.explanation,
+            subfolder: toolUse.input.subfolder,
+            columns: toolUse.input.columns
+          });
+        }
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolUse.id,
+          content: result
+        });
+      }
+      messages.push({ role: "user", content: toolResults });
+    }
+    return {
+      response: "Reached maximum tool call rounds. Here are the suggestions gathered so far.",
+      proposals,
+      messages
+    };
+  }
+  buildSystemPrompt(context) {
+    const parts = [SYSTEM_PROMPT];
+    parts.push(`
+## Current Project Summary`);
+    parts.push(`- Yamchart: ${context.yamchart.models.length} SQL models, ${context.yamchart.charts.length} charts, ${context.yamchart.dashboards.length} dashboards`);
+    parts.push(`- dbt project: "${context.dbt.projectName}" at ${context.dbt.projectPath}`);
+    parts.push(`- dbt models: ${context.dbt.models.length} (layers: ${context.dbt.conventions.folderStructure.join(", ") || "none detected"})`);
+    if (Object.keys(context.dbt.conventions.namingPrefixes).length > 0) {
+      const prefixes = Object.entries(context.dbt.conventions.namingPrefixes).map(([layer, prefix]) => `${layer}: ${prefix}`).join(", ");
+      parts.push(`- Naming prefixes: ${prefixes}`);
+    }
+    if (Object.keys(context.dbt.conventions.commonMaterializations).length > 0) {
+      const mats = Object.entries(context.dbt.conventions.commonMaterializations).map(([layer, mat]) => `${layer}: ${mat}`).join(", ");
+      parts.push(`- Materializations: ${mats}`);
+    }
+    parts.push(`- Schema.yml pattern: ${context.dbt.conventions.schemaYmlPattern}`);
+    parts.push(`- Catalog: ${context.yamchart.catalog ? "available" : "not synced"}`);
+    parts.push(`- Warehouse: ${context.warehouse ? `connected (${context.warehouse.connectionType})` : "not connected"}`);
+    return parts.join("\n");
+  }
+};
+
+// ../../packages/advisor/dist/providers/anthropic.js
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  client;
+  model;
+  constructor(apiKey, model = "claude-sonnet-4-5-20250929") {
+    this.client = new Anthropic({ apiKey });
+    this.model = model;
+  }
+  async chat(options) {
+    const tools = options.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: {
+        type: "object",
+        properties: t.parameters.properties,
+        required: t.parameters.required ?? []
+      }
+    }));
+    const messages = options.messages.map((m) => {
+      if (typeof m.content === "string") {
+        return { role: m.role, content: m.content };
+      }
+      const blocks = m.content.map((block) => {
+        if (block.type === "text") {
+          return { type: "text", text: block.text };
+        }
+        if (block.type === "tool_use") {
+          const tu = block;
+          return { type: "tool_use", id: tu.id, name: tu.name, input: tu.input };
+        }
+        if (block.type === "tool_result") {
+          const tr = block;
+          return { type: "tool_result", tool_use_id: tr.tool_use_id, content: tr.content };
+        }
+        throw new Error(`Unknown block type: ${block.type}`);
+      });
+      return { role: m.role, content: blocks };
+    });
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: options.maxTokens ?? 4096,
+      system: options.system,
+      tools,
+      messages
+    });
+    const content = response.content.map((block) => {
+      if (block.type === "text") {
+        return { type: "text", text: block.text };
+      }
+      if (block.type === "tool_use") {
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      }
+      throw new Error(`Unexpected block type: ${block.type}`);
+    });
+    return {
+      content,
+      stopReason: response.stop_reason === "tool_use" ? "tool_use" : "end"
+    };
+  }
+};
+
+// ../../packages/advisor/dist/dbt/writer.js
+import { readFile as readFile3, writeFile, mkdir, access } from "fs/promises";
+import { join as join3, dirname as dirname3 } from "path";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+function buildModelPath(modelName, layer, conventions, subfolder) {
+  const effectiveLayer = layer ?? (conventions.folderStructure.includes("marts") ? "marts" : conventions.folderStructure[0] ?? "models");
+  const parts = ["models", effectiveLayer];
+  if (subfolder)
+    parts.push(subfolder);
+  parts.push(`${modelName}.sql`);
+  return parts.join("/");
+}
+function formatModelSql(options) {
+  const lines = [];
+  if (options.materialization !== "view") {
+    const configParts = [`materialized='${options.materialization}'`];
+    if (options.tags && options.tags.length > 0) {
+      configParts.push(`tags=[${options.tags.map((t) => `'${t}'`).join(", ")}]`);
+    }
+    lines.push(`{{
+  config(
+    ${configParts.join(",\n    ")}
+  )
+}}
+`);
+  }
+  lines.push(options.sql);
+  return lines.join("\n");
+}
+function buildSchemaYmlEntry(options) {
+  const model = {
+    name: options.name,
+    description: options.description
+  };
+  if (options.columns && options.columns.length > 0) {
+    model.columns = options.columns.map((col) => {
+      const entry = { name: col.name };
+      if (col.description)
+        entry.description = col.description;
+      if (col.tests && col.tests.length > 0)
+        entry.tests = col.tests;
+      return entry;
+    });
+  }
+  return stringifyYaml({ models: [model] }, { indent: 2 });
+}
+async function writeDbtModel(projectPath, modelPath, sql) {
+  const fullPath = join3(projectPath, modelPath);
+  await mkdir(dirname3(fullPath), { recursive: true });
+  await writeFile(fullPath, sql + "\n", "utf-8");
+  return fullPath;
+}
+async function updateSchemaYml(projectPath, schemaPath, entry) {
+  const fullPath = join3(projectPath, schemaPath);
+  let existing = {
+    version: 2,
+    models: []
+  };
+  try {
+    await access(fullPath);
+    const content = await readFile3(fullPath, "utf-8");
+    existing = parseYaml2(content);
+    if (!existing.models)
+      existing.models = [];
+  } catch {
+    await mkdir(dirname3(fullPath), { recursive: true });
+  }
+  const idx = existing.models.findIndex((m) => m.name === entry.name);
+  const modelEntry = {
+    name: entry.name,
+    description: entry.description
+  };
+  if (entry.columns && entry.columns.length > 0) {
+    modelEntry.columns = entry.columns.map((col) => {
+      const c = { name: col.name };
+      if (col.description)
+        c.description = col.description;
+      if (col.tests && col.tests.length > 0)
+        c.tests = col.tests;
+      return c;
+    });
+  }
+  if (idx >= 0) {
+    existing.models[idx] = modelEntry;
+  } else {
+    existing.models.push(modelEntry);
+  }
+  await writeFile(fullPath, stringifyYaml(existing, { indent: 2 }), "utf-8");
+  return fullPath;
+}
+export {
+  AdvisorAgent,
+  AnthropicProvider,
+  KNOWLEDGE_TOPICS,
+  SYSTEM_PROMPT,
+  TOOL_DEFINITIONS,
+  buildModelPath,
+  buildSchemaYmlEntry,
+  detectConventions,
+  formatModelSql,
+  getKnowledgeOverview,
+  listDbtModels,
+  loadKnowledge,
+  readDbtModel,
+  updateSchemaYml,
+  writeDbtModel
+};
+//# sourceMappingURL=dist-ZRRM3OWF.js.map