yamchart 0.9.5 → 0.10.0

package/dist/dist-MNXSMGV6.js

@@ -1,790 +0,0 @@
-import "./chunk-S7YQXEKM.js";
-import {
-  SemanticModelBuilder,
-  SemanticQueryCompiler
-} from "./chunk-UND73EOB.js";
-import "./chunk-7D4SUZUM.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",
-  "sources"
-];
-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: "get_warehouse_table",
-    description: "Get detailed column metadata and sample rows for a specific warehouse table from the cached catalog. Instant \u2014 reads from local catalog, no live query. Use the fully-qualified name (e.g. RAW.PAYMENTS).",
-    parameters: {
-      type: "object",
-      properties: {
-        table: { type: "string", description: "Fully-qualified table name (e.g. RAW.PAYMENTS, STAGING.CUSTOMERS)" }
-      },
-      required: ["table"]
-    }
-  },
-  {
-    name: "get_warehouse_tables",
-    description: "Get detailed metadata for multiple warehouse tables at once from the cached catalog.",
-    parameters: {
-      type: "object",
-      properties: {
-        tables: { type: "array", items: { type: "string" }, description: "List of fully-qualified table names" }
-      },
-      required: ["tables"]
-    }
-  },
-  {
-    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"]
-    }
-  },
-  {
-    name: "list_semantic_entities",
-    description: "List all semantic entities (auto-generated from the catalog) with their measures and dimensions. Use this to understand what data is available for structured queries without writing SQL.",
-    parameters: { type: "object", properties: {}, required: [] }
-  },
-  {
-    name: "semantic_query",
-    description: "Run a structured query against the semantic layer. Specify an entity, measures to aggregate, and optional dimensions to group by. Returns the compiled SQL.",
-    parameters: {
-      type: "object",
-      properties: {
-        entity: { type: "string", description: "Entity name (e.g. fct_revenue)" },
-        measures: { type: "array", items: { type: "string" }, description: "Measure names to aggregate" },
-        dimensions: { type: "array", items: { type: "string" }, description: "Dimension names to group by (optional)" },
-        filters: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              dimension: { type: "string" },
-              operator: { type: "string", description: "equals, not_equals, contains, gt, gte, lt, lte, in, not_in" },
-              value: { description: "Filter value (string, number, or array for in/not_in)" }
-            },
-            required: ["dimension", "operator", "value"]
-          },
-          description: "Optional filters"
-        },
-        limit: { type: "number", description: "Row limit (default: 100)" }
-      },
-      required: ["entity", "measures"]
-    }
-  },
-  // 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 "get_warehouse_table": {
-      if (!context.yamchart.catalogJson) {
-        return "Warehouse catalog not available. Run `yamchart sync-warehouse` to populate it.";
-      }
-      const tableName = input.table.toUpperCase();
-      const match = context.yamchart.catalogJson.models.find((m) => (m.table || "").toUpperCase() === tableName || m.name.toUpperCase() === tableName);
-      if (!match) {
-        return JSON.stringify({ error: `Table not found in catalog: ${input.table}. Use get_catalog to see available tables.` });
-      }
-      return JSON.stringify({
-        name: match.name,
-        table: match.table,
-        tableType: match.tableType,
-        source: match.source,
-        columns: match.columns,
-        sampleRows: match.sampleRows || []
-      });
-    }
-    case "get_warehouse_tables": {
-      if (!context.yamchart.catalogJson) {
-        return "Warehouse catalog not available. Run `yamchart sync-warehouse` to populate it.";
-      }
-      const tableNames = input.tables.map((t) => t.toUpperCase());
-      const results = tableNames.map((name) => {
-        const match = context.yamchart.catalogJson.models.find((m) => (m.table || "").toUpperCase() === name || m.name.toUpperCase() === name);
-        if (!match) {
-          return { error: `Not found: ${name}` };
-        }
-        return {
-          name: match.name,
-          table: match.table,
-          tableType: match.tableType,
-          source: match.source,
-          columns: match.columns,
-          sampleRows: match.sampleRows || []
-        };
-      });
-      return JSON.stringify(results);
-    }
-    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 "list_semantic_entities": {
-      if (!context.yamchart.catalogJson) {
-        return "No catalog available. Run `yamchart sync-warehouse` or `yamchart sync-dbt` to populate it.";
-      }
-      const builder = new SemanticModelBuilder();
-      const model = builder.build({ catalog: { models: context.yamchart.catalogJson.models } });
-      return JSON.stringify(model.entities.map((e) => ({
-        name: e.name,
-        source_table: e.source_table,
-        description: e.description,
-        measures: e.measures.map((m) => ({ name: m.name, type: m.type })),
-        dimensions: e.dimensions.map((d) => ({ name: d.name, type: d.type }))
-      })));
-    }
-    case "semantic_query": {
-      if (!context.yamchart.catalogJson) {
-        return JSON.stringify({ error: "No catalog available. Run `yamchart sync-warehouse` or `yamchart sync-dbt` to populate it." });
-      }
-      try {
-        const builder = new SemanticModelBuilder();
-        const model = builder.build({ catalog: { models: context.yamchart.catalogJson.models } });
-        const compiler = new SemanticQueryCompiler();
-        const sql = compiler.compile(model, {
-          model: input.entity,
-          measures: input.measures || [],
-          dimensions: input.dimensions || [],
-          filters: input.filters || [],
-          limit: input.limit || 100
-        });
-        return JSON.stringify({ sql, entity: input.entity });
-      } catch (err) {
-        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
-      }
-    }
-    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 working with cross-database tables:
-- If a table lives outside the primary analytics database, recommend creating a dbt source definition in sources.yml
-- Follow the pattern: source \u2192 staging model \u2192 downstream refs
-- Use get_knowledge('sources') for detailed source patterns
-- Check the warehouse catalog (get_warehouse_tables) to identify tables in other databases
-
-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-MNXSMGV6.js.map