@deepagents/text2sql 0.10.1 → 0.11.0

package/dist/lib/instructions.js

@@ -1,403 +1,420 @@
-// packages/text2sql/src/lib/teach/xml.ts
-function wrapBlock(tag, children) {
-  const content = children.filter((child) => Boolean(child)).join("\n");
-  if (!content) {
-    return "";
-  }
-  return `<${tag}>
-${indentBlock(content, 2)}
-</${tag}>`;
+// packages/context/dist/index.js
+import { encode } from "gpt-tokenizer";
+import { generateId } from "ai";
+import pluralize from "pluralize";
+import { titlecase } from "stringcase";
+import { defineCommand } from "just-bash";
+import spawn from "nano-spawn";
+import "bash-tool";
+import spawn2 from "nano-spawn";
+import {
+  createBashTool
+} from "bash-tool";
+import YAML from "yaml";
+import { DatabaseSync } from "node:sqlite";
+import {
+  Output,
+  convertToModelMessages,
+  createUIMessageStream,
+  generateId as generateId2,
+  generateText,
+  smoothStream,
+  stepCountIs,
+  streamText
+} from "ai";
+import chalk from "chalk";
+import "zod";
+import "@deepagents/agent";
+function isFragment(data) {
+  return typeof data === "object" && data !== null && "name" in data && "data" in data && typeof data.name === "string";
 }
-function list(tag, values, childTag) {
-  if (!values.length) {
-    return "";
+function isFragmentObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data) && !isFragment(data);
+}
+function fragment(name, ...children) {
+  return {
+    name,
+    data: children
+  };
+}
+function role(content) {
+  return {
+    name: "role",
+    data: content
+  };
+}
+var ContextRenderer = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Check if data is a primitive (string, number, boolean).
+   */
+  isPrimitive(data) {
+    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
+  }
+  /**
+   * Group fragments by name for groupFragments option.
+   */
+  groupByName(fragments) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const fragment2 of fragments) {
+      const existing = groups.get(fragment2.name) ?? [];
+      existing.push(fragment2);
+      groups.set(fragment2.name, existing);
+    }
+    return groups;
+  }
+  /**
+   * Template method - dispatches value to appropriate handler.
+   */
+  renderValue(key, value, ctx) {
+    if (value == null) {
+      return "";
+    }
+    if (isFragment(value)) {
+      return this.renderFragment(value, ctx);
+    }
+    if (Array.isArray(value)) {
+      return this.renderArray(key, value, ctx);
+    }
+    if (isFragmentObject(value)) {
+      return this.renderObject(key, value, ctx);
+    }
+    return this.renderPrimitive(key, String(value), ctx);
+  }
+  /**
+   * Render all entries of an object.
+   */
+  renderEntries(data, ctx) {
+    return Object.entries(data).map(([key, value]) => this.renderValue(key, value, ctx)).filter(Boolean);
+  }
+};
+var XmlRenderer = class extends ContextRenderer {
+  render(fragments) {
+    return fragments.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
+  }
+  #renderTopLevel(fragment2) {
+    if (this.isPrimitive(fragment2.data)) {
+      return this.#leafRoot(fragment2.name, String(fragment2.data));
+    }
+    if (Array.isArray(fragment2.data)) {
+      return this.#renderArray(fragment2.name, fragment2.data, 0);
+    }
+    if (isFragment(fragment2.data)) {
+      const child = this.renderFragment(fragment2.data, { depth: 1, path: [] });
+      return this.#wrap(fragment2.name, [child]);
+    }
+    return this.#wrap(
+      fragment2.name,
+      this.renderEntries(fragment2.data, { depth: 1, path: [] })
+    );
   }
-  const children = values.map((value) => leaf(childTag, value)).join("\n");
-  return `<${tag}>
-${indentBlock(children, 2)}
+  #renderArray(name, items, depth) {
+    const fragmentItems = items.filter(isFragment);
+    const nonFragmentItems = items.filter((item) => !isFragment(item));
+    const children = [];
+    for (const item of nonFragmentItems) {
+      if (item != null) {
+        children.push(
+          this.#leaf(pluralize.singular(name), String(item), depth + 1)
+        );
+      }
+    }
+    if (this.options.groupFragments && fragmentItems.length > 0) {
+      const groups = this.groupByName(fragmentItems);
+      for (const [groupName, groupFragments] of groups) {
+        const groupChildren = groupFragments.map(
+          (frag) => this.renderFragment(frag, { depth: depth + 2, path: [] })
+        );
+        const pluralName = pluralize.plural(groupName);
+        children.push(this.#wrapIndented(pluralName, groupChildren, depth + 1));
+      }
+    } else {
+      for (const frag of fragmentItems) {
+        children.push(
+          this.renderFragment(frag, { depth: depth + 1, path: [] })
+        );
+      }
+    }
+    return this.#wrap(name, children);
+  }
+  #leafRoot(tag, value) {
+    const safe = this.#escape(value);
+    if (safe.includes("\n")) {
+      return `<${tag}>
+${this.#indent(safe, 2)}
 </${tag}>`;
-}
-function leaf(tag, value) {
-  const safe = escapeXml(value);
-  if (safe.includes("\n")) {
+    }
+    return `<${tag}>${safe}</${tag}>`;
+  }
+  renderFragment(fragment2, ctx) {
+    const { name, data } = fragment2;
+    if (this.isPrimitive(data)) {
+      return this.#leaf(name, String(data), ctx.depth);
+    }
+    if (isFragment(data)) {
+      const child = this.renderFragment(data, { ...ctx, depth: ctx.depth + 1 });
+      return this.#wrapIndented(name, [child], ctx.depth);
+    }
+    if (Array.isArray(data)) {
+      return this.#renderArrayIndented(name, data, ctx.depth);
+    }
+    const children = this.renderEntries(data, { ...ctx, depth: ctx.depth + 1 });
+    return this.#wrapIndented(name, children, ctx.depth);
+  }
+  #renderArrayIndented(name, items, depth) {
+    const fragmentItems = items.filter(isFragment);
+    const nonFragmentItems = items.filter((item) => !isFragment(item));
+    const children = [];
+    for (const item of nonFragmentItems) {
+      if (item != null) {
+        children.push(
+          this.#leaf(pluralize.singular(name), String(item), depth + 1)
+        );
+      }
+    }
+    if (this.options.groupFragments && fragmentItems.length > 0) {
+      const groups = this.groupByName(fragmentItems);
+      for (const [groupName, groupFragments] of groups) {
+        const groupChildren = groupFragments.map(
+          (frag) => this.renderFragment(frag, { depth: depth + 2, path: [] })
+        );
+        const pluralName = pluralize.plural(groupName);
+        children.push(this.#wrapIndented(pluralName, groupChildren, depth + 1));
+      }
+    } else {
+      for (const frag of fragmentItems) {
+        children.push(
+          this.renderFragment(frag, { depth: depth + 1, path: [] })
+        );
+      }
+    }
+    return this.#wrapIndented(name, children, depth);
+  }
+  renderPrimitive(key, value, ctx) {
+    return this.#leaf(key, value, ctx.depth);
+  }
+  renderArray(key, items, ctx) {
+    if (!items.length) {
+      return "";
+    }
+    const itemTag = pluralize.singular(key);
+    const children = items.filter((item) => item != null).map((item) => this.#leaf(itemTag, String(item), ctx.depth + 1));
+    return this.#wrapIndented(key, children, ctx.depth);
+  }
+  renderObject(key, obj, ctx) {
+    const children = this.renderEntries(obj, { ...ctx, depth: ctx.depth + 1 });
+    return this.#wrapIndented(key, children, ctx.depth);
+  }
+  #escape(value) {
+    if (value == null) {
+      return "";
+    }
+    return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
+  }
+  #indent(text, spaces) {
+    if (!text.trim()) {
+      return "";
+    }
+    const padding = " ".repeat(spaces);
+    return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
+  }
+  #leaf(tag, value, depth) {
+    const safe = this.#escape(value);
+    const pad = "  ".repeat(depth);
+    if (safe.includes("\n")) {
+      return `${pad}<${tag}>
+${this.#indent(safe, (depth + 1) * 2)}
+${pad}</${tag}>`;
+    }
+    return `${pad}<${tag}>${safe}</${tag}>`;
+  }
+  #wrap(tag, children) {
+    const content = children.filter(Boolean).join("\n");
+    if (!content) {
+      return "";
+    }
     return `<${tag}>
-${indentBlock(safe, 2)}
+${content}
 </${tag}>`;
   }
-  return `<${tag}>${safe}</${tag}>`;
-}
-function indentBlock(text, spaces) {
-  if (!text.trim()) {
-    return "";
-  }
-  const padding = " ".repeat(spaces);
-  return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
-}
-function escapeXml(value) {
-  if (value == null) {
-    return "";
+  #wrapIndented(tag, children, depth) {
+    const content = children.filter(Boolean).join("\n");
+    if (!content) {
+      return "";
+    }
+    const pad = "  ".repeat(depth);
+    return `${pad}<${tag}>
+${content}
+${pad}</${tag}>`;
   }
-  return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
-}
-
-// packages/text2sql/src/lib/teach/teachables.ts
+};
 function term(name, definition) {
   return {
-    type: "term",
-    encode: () => ({ type: "term", name, definition }),
-    decode: () => wrapBlock("term", [leaf("name", name), leaf("definition", definition)])
+    name: "term",
+    data: { name, definition }
   };
 }
 function hint(text) {
   return {
-    type: "hint",
-    encode: () => ({ type: "hint", text }),
-    decode: () => leaf("hint", text)
+    name: "hint",
+    data: text
   };
 }
 function guardrail(input) {
-  const { rule, reason, action } = input;
   return {
-    type: "guardrail",
-    encode: () => ({ type: "guardrail", rule, reason, action }),
-    decode: () => wrapBlock("guardrail", [
-      leaf("rule", rule),
-      reason ? leaf("reason", reason) : "",
-      action ? leaf("action", action) : ""
-    ])
+    name: "guardrail",
+    data: {
+      rule: input.rule,
+      ...input.reason && { reason: input.reason },
+      ...input.action && { action: input.action }
+    }
   };
 }
 function explain(input) {
-  const { concept, explanation, therefore } = input;
   return {
-    type: "explain",
-    encode: () => ({ type: "explain", concept, explanation, therefore }),
-    decode: () => wrapBlock("explanation", [
-      leaf("concept", concept),
-      leaf("details", explanation),
-      therefore ? leaf("therefore", therefore) : ""
-    ])
+    name: "explain",
+    data: {
+      concept: input.concept,
+      explanation: input.explanation,
+      ...input.therefore && { therefore: input.therefore }
+    }
   };
 }
 function example(input) {
-  const { question, answer, note } = input;
   return {
-    type: "example",
-    encode: () => ({ type: "example", question, answer, note }),
-    decode: () => wrapBlock("example", [
-      leaf("question", question),
-      leaf("answer", answer),
-      note ? leaf("note", note) : ""
-    ])
+    name: "example",
+    data: {
+      question: input.question,
+      answer: input.answer,
+      ...input.note && { note: input.note }
+    }
   };
 }
 function clarification(input) {
-  const { when, ask, reason } = input;
   return {
-    type: "clarification",
-    encode: () => ({ type: "clarification", when, ask, reason }),
-    decode: () => wrapBlock("clarification", [
-      leaf("when", when),
-      leaf("ask", ask),
-      leaf("reason", reason)
-    ])
+    name: "clarification",
+    data: {
+      when: input.when,
+      ask: input.ask,
+      reason: input.reason
+    }
   };
 }
 function workflow(input) {
-  const { task, steps, triggers, notes } = input;
   return {
-    type: "workflow",
-    encode: () => ({ type: "workflow", task, steps, triggers, notes }),
-    decode: () => wrapBlock("workflow", [
-      leaf("task", task),
-      triggers?.length ? list("triggers", triggers, "trigger") : "",
-      list("steps", steps, "step"),
-      notes ? leaf("notes", notes) : ""
-    ])
+    name: "workflow",
+    data: {
+      task: input.task,
+      steps: input.steps,
+      ...input.triggers?.length && { triggers: input.triggers },
+      ...input.notes && { notes: input.notes }
+    }
   };
 }
 function quirk(input) {
-  const { issue, workaround } = input;
   return {
-    type: "quirk",
-    encode: () => ({ type: "quirk", issue, workaround }),
-    decode: () => wrapBlock("quirk", [
-      leaf("issue", issue),
-      leaf("workaround", workaround)
-    ])
+    name: "quirk",
+    data: {
+      issue: input.issue,
+      workaround: input.workaround
+    }
   };
 }
 function styleGuide(input) {
-  const { prefer, never, always } = input;
   return {
-    type: "styleGuide",
-    encode: () => ({ type: "styleGuide", prefer, never, always }),
-    decode: () => wrapBlock("style_guide", [
-      leaf("prefer", prefer),
-      always ? leaf("always", always) : "",
-      never ? leaf("never", never) : ""
-    ])
+    name: "styleGuide",
+    data: {
+      prefer: input.prefer,
+      ...input.never && { never: input.never },
+      ...input.always && { always: input.always }
+    }
   };
 }
 function analogy(input) {
-  const { concept, relationship, insight, therefore, pitfall } = input;
   return {
-    type: "analogy",
-    encode: () => ({
-      type: "analogy",
-      concept,
-      relationship,
-      insight,
-      therefore,
-      pitfall
-    }),
-    decode: () => wrapBlock("analogy", [
-      list("concepts", concept, "concept"),
-      leaf("relationship", relationship),
-      insight ? leaf("insight", insight) : "",
-      therefore ? leaf("therefore", therefore) : "",
-      pitfall ? leaf("pitfall", pitfall) : ""
-    ])
+    name: "analogy",
+    data: {
+      concepts: input.concepts,
+      relationship: input.relationship,
+      ...input.insight && { insight: input.insight },
+      ...input.therefore && { therefore: input.therefore },
+      ...input.pitfall && { pitfall: input.pitfall }
+    }
   };
 }
 function glossary(entries) {
   return {
-    type: "glossary",
-    encode: () => ({ type: "glossary", entries }),
-    decode: () => wrapBlock(
-      "glossary",
-      Object.entries(entries).map(
-        ([term2, sql]) => wrapBlock("entry", [leaf("term", term2), leaf("sql", sql)])
-      )
-    )
+    name: "glossary",
+    data: Object.entries(entries).map(([term2, expression]) => ({
+      term: term2,
+      expression
+    }))
   };
 }
 function identity(input) {
-  const { name, role } = input;
   return {
-    type: "identity",
-    encode: () => ({ type: "identity", name, role }),
-    decode: () => wrapBlock("identity", [
-      name ? leaf("name", name) : "",
-      role ? leaf("role", role) : ""
-    ])
+    name: "identity",
+    data: {
+      ...input.name && { name: input.name },
+      ...input.role && { role: input.role }
+    }
   };
 }
 function persona(input) {
-  const { name, role, tone } = input;
   return {
-    type: "persona",
-    encode: () => ({ type: "persona", name, role, tone: tone ?? "" }),
-    decode: () => wrapBlock("persona", [
-      leaf("name", name),
-      leaf("role", role),
-      tone ? leaf("tone", tone) : ""
-    ])
+    name: "persona",
+    data: {
+      name: input.name,
+      role: input.role,
+      ...input.tone && { tone: input.tone }
+    }
   };
 }
-function alias(termName, meaning) {
+function alias(term2, meaning) {
   return {
-    type: "alias",
-    encode: () => ({ type: "alias", term: termName, meaning }),
-    decode: () => wrapBlock("alias", [leaf("term", termName), leaf("meaning", meaning)])
+    name: "alias",
+    data: { term: term2, meaning }
   };
 }
 function preference(aspect, value) {
   return {
-    type: "preference",
-    encode: () => ({ type: "preference", aspect, value }),
-    decode: () => wrapBlock("preference", [leaf("aspect", aspect), leaf("value", value)])
+    name: "preference",
+    data: { aspect, value }
   };
 }
-function context(description) {
+function userContext(description) {
   return {
-    type: "context",
-    encode: () => ({ type: "context", description }),
-    decode: () => leaf("context", description)
+    name: "userContext",
+    data: description
   };
 }
 function correction(subject, clarification2) {
   return {
-    type: "correction",
-    encode: () => ({ type: "correction", subject, clarification: clarification2 }),
-    decode: () => wrapBlock("correction", [
-      leaf("subject", subject),
-      leaf("clarification", clarification2)
-    ])
-  };
-}
-function teachable(tag, ...teachables) {
-  return {
-    type: "user_profile",
-    encode: () => teachables[0]?.encode() ?? { type: "context", description: "" },
-    decode: () => toInstructions(tag, ...teachables)
+    name: "correction",
+    data: { subject, clarification: clarification2 }
   };
 }
-function toInstructions(tag, ...teachables) {
-  if (!teachables.length) {
-    return "";
-  }
-  const grouped = /* @__PURE__ */ new Map();
-  for (const teachable2 of teachables) {
-    const existing = grouped.get(teachable2.type) ?? [];
-    existing.push(teachable2);
-    grouped.set(teachable2.type, existing);
-  }
-  const definedTypes = new Set(SECTION_ORDER.map((s) => s.type));
-  const sections = SECTION_ORDER.map(({ type, tag: tag2 }) => {
-    const items = grouped.get(type);
-    if (!items?.length) {
-      return "";
-    }
-    const renderedItems = items.map((item) => item.decode().trim()).filter(Boolean).map((item) => indentBlock(item, 2)).join("\n");
-    if (!renderedItems.length) {
-      return "";
-    }
-    return `<${tag2}>
-${renderedItems}
-</${tag2}>`;
-  }).filter((section) => Boolean(section));
-  for (const [type, items] of grouped) {
-    if (definedTypes.has(type)) {
-      continue;
-    }
-    const renderedItems = items.map((item) => item.decode().trim()).filter(Boolean).map((item) => indentBlock(item, 2)).join("\n");
-    if (renderedItems.length) {
-      sections.push(renderedItems);
-    }
-  }
-  if (!sections.length) {
+
+// packages/text2sql/src/lib/instructions.ts
+function toInstructions(tag, ...fragments) {
+  if (fragments.length === 0) {
     return "";
   }
-  const content = indentBlock(sections.join("\n"), 2);
-  return `<${tag}>
-${content}
-</${tag}>`;
-}
-var SECTION_ORDER = [
-  // User context (render first - most important for personalization)
-  { type: "identity", tag: "identity" },
-  { type: "persona", tag: "persona" },
-  { type: "context", tag: "user_context" },
-  { type: "preference", tag: "user_preferences" },
-  { type: "alias", tag: "user_vocabulary" },
-  { type: "correction", tag: "user_corrections" },
-  // Domain knowledge
-  { type: "guardrail", tag: "guardrails" },
-  { type: "styleGuide", tag: "style_guides" },
-  { type: "hint", tag: "hints" },
-  { type: "clarification", tag: "clarifications" },
-  { type: "workflow", tag: "workflows" },
-  { type: "quirk", tag: "quirks" },
-  { type: "term", tag: "terminology" },
-  { type: "explain", tag: "explanations" },
-  { type: "analogy", tag: "analogies" },
-  { type: "glossary", tag: "glossary" },
-  { type: "example", tag: "examples" }
-];
-function toTeachables(generated) {
-  return generated.map((item) => {
-    switch (item.type) {
-      case "persona":
-        return persona({ name: item.name, role: item.role, tone: item.tone });
-      case "term":
-        return term(item.name, item.definition);
-      case "hint":
-        return hint(item.text);
-      case "guardrail":
-        return guardrail({
-          rule: item.rule,
-          reason: item.reason,
-          action: item.action
-        });
-      case "explain":
-        return explain({
-          concept: item.concept,
-          explanation: item.explanation,
-          therefore: item.therefore
-        });
-      case "example":
-        return example({
-          question: item.question,
-          answer: item.answer,
-          note: item.note
-        });
-      case "clarification":
-        return clarification({
-          when: item.when,
-          ask: item.ask,
-          reason: item.reason
-        });
-      case "workflow":
-        return workflow({
-          task: item.task,
-          steps: item.steps,
-          triggers: item.triggers,
-          notes: item.notes
-        });
-      case "quirk":
-        return quirk({
-          issue: item.issue,
-          workaround: item.workaround
-        });
-      case "styleGuide":
-        return styleGuide({
-          prefer: item.prefer,
-          never: item.never,
-          always: item.always
-        });
-      case "analogy":
-        return analogy({
-          concept: item.concept,
-          relationship: item.relationship,
-          insight: item.insight,
-          therefore: item.therefore,
-          pitfall: item.pitfall
-        });
-      case "glossary":
-        return glossary(item.entries);
-      // User-specific teachable types
-      case "identity":
-        return identity({ name: item.name, role: item.role });
-      case "alias":
-        return alias(item.term, item.meaning);
-      case "preference":
-        return preference(item.aspect, item.value);
-      case "context":
-        return context(item.description);
-      case "correction":
-        return correction(item.subject, item.clarification);
-    }
-  });
+  const renderer = new XmlRenderer({ groupFragments: true });
+  const wrapped = fragment(tag, ...fragments);
+  return renderer.render([wrapped]);
 }
-function fromTeachables(teachables) {
-  return teachables.map((t) => t.encode());
-}
-var teachables_default = {
-  persona,
-  term,
-  hint,
-  guardrail,
-  explain,
-  example,
-  clarification,
-  workflow,
-  quirk,
-  styleGuide,
-  analogy,
-  glossary,
-  teachable
-};
 export {
   alias,
   analogy,
   clarification,
-  context,
   correction,
-  teachables_default as default,
   example,
   explain,
-  fromTeachables,
+  fragment,
   glossary,
   guardrail,
   hint,
@@ -405,11 +422,11 @@ export {
   persona,
   preference,
   quirk,
+  role,
   styleGuide,
-  teachable,
   term,
   toInstructions,
-  toTeachables,
+  userContext,
   workflow
 };
 //# sourceMappingURL=instructions.js.map