@harperfast/agent 0.16.0 → 0.16.2

package/dist/agent.js

@@ -875,9 +875,9 @@ async function execute10({ skill }) {
 
 // tools/files/workspaceEditor.ts
 import { applyDiff } from "@openai/agents";
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
 import { mkdir, rm, writeFile } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 
 // utils/files/normalizeDiff.ts
 function normalizeDiff(diff) {
@@ -993,6 +993,61 @@ function resolvePath(root, relativePath) {
   return resolved;
 }
 
+// utils/files/validateGraphQL.ts
+import { buildSchema, extendSchema, parse, validateSchema } from "graphql";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+var __dirname = path4.dirname(fileURLToPath(import.meta.url));
+var cachedSchema = null;
+function getHarperSchema(root) {
+  if (cachedSchema) {
+    return cachedSchema;
+  }
+  const paths = [
+    path4.join(root, "node_modules", "harperdb", "schema.graphql"),
+    path4.join(__dirname, "schema.graphql"),
+    path4.join(__dirname, "..", "schema.graphql"),
+    path4.join(__dirname, "..", "..", "schema.graphql")
+  ];
+  for (const schemaPath of paths) {
+    if (existsSync6(schemaPath)) {
+      try {
+        const schemaSource = readFileSync4(schemaPath, "utf8");
+        cachedSchema = buildSchema(schemaSource, { assumeValidSDL: true });
+        return cachedSchema;
+      } catch (e) {
+        console.error(`Error parsing HarperDB schema at ${schemaPath}:`, e);
+      }
+    }
+  }
+  return null;
+}
+function validateGraphQL(content, filePath, root) {
+  if (!filePath.endsWith(".graphql")) {
+    return null;
+  }
+  try {
+    const document2 = parse(content);
+    const schema = getHarperSchema(root);
+    if (schema) {
+      const extendedSchema = extendSchema(schema, document2, { assumeValidSDL: false });
+      const errors = validateSchema(extendedSchema).filter(
+        (e) => !e.message.includes("Query root type must be provided")
+      );
+      if (errors.length > 0) {
+        return `GraphQL validation error in ${filePath}:
+${errors.map((e) => e.message).join("\n")}`;
+      }
+    }
+    return null;
+  } catch (err) {
+    const message = err.message || String(err);
+    const type = message.includes("Syntax Error") ? "syntax" : "validation";
+    return `GraphQL ${type} error in ${filePath}: ${message}`;
+  }
+}
+
 // tools/files/workspaceEditor.ts
 var WorkspaceEditor = class {
   root;
@@ -1002,11 +1057,18 @@ var WorkspaceEditor = class {
   async createFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      await mkdir(path4.dirname(targetPath), { recursive: true });
+      await mkdir(path5.dirname(targetPath), { recursive: true });
       const normalizedDiff = normalizeDiff(operation.diff);
       const content = applyDiff("", normalizedDiff, "create");
       await writeFile(targetPath, content, "utf8");
-      return { status: "completed", output: `Created ${operation.path}` };
+      let output = `Created ${operation.path}`;
+      const validationError = validateGraphQL(content, operation.path, this.root());
+      if (validationError) {
+        output += `
+
+${validationError}`;
+      }
+      return { status: "completed", output };
     } catch (err) {
       return { status: "failed", output: `Error creating ${operation.path}: ${String(err)}` };
     }
@@ -1014,14 +1076,21 @@ var WorkspaceEditor = class {
   async updateFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      if (!existsSync6(targetPath)) {
+      if (!existsSync7(targetPath)) {
         return { status: "failed", output: "Error: file not found at path " + targetPath };
       }
-      const original = readFileSync4(targetPath, "utf8");
+      const original = readFileSync5(targetPath, "utf8");
       const normalizedDiff = normalizeDiff(operation.diff);
       const patched = applyDiff(original, normalizedDiff);
       await writeFile(targetPath, patched, "utf8");
-      return { status: "completed", output: `Updated ${operation.path}` };
+      let output = `Updated ${operation.path}`;
+      const validationError = validateGraphQL(patched, operation.path, this.root());
+      if (validationError) {
+        output += `
+
+${validationError}`;
+      }
+      return { status: "completed", output };
     } catch (err) {
       return { status: "failed", output: `Error updating ${operation.path}: ${String(err)}` };
     }
@@ -1029,7 +1098,7 @@ var WorkspaceEditor = class {
   async overwriteFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      await mkdir(path4.dirname(targetPath), { recursive: true });
+      await mkdir(path5.dirname(targetPath), { recursive: true });
       const normalizedInput = normalizeDiff(operation.diff);
       const lines = normalizedInput.split(/\r?\n/);
       const hasDiffMarkers = lines.some((line) => line.startsWith("+") || line.startsWith("-"));
@@ -1040,7 +1109,14 @@ var WorkspaceEditor = class {
         finalContent = normalizedInput;
       }
       await writeFile(targetPath, finalContent, "utf8");
-      return { status: "completed", output: `Overwrote ${operation.path}` };
+      let output = `Overwrote ${operation.path}`;
+      const validationError = validateGraphQL(finalContent, operation.path, this.root());
+      if (validationError) {
+        output += `
+
+${validationError}`;
+      }
+      return { status: "completed", output };
     } catch (err) {
       return { status: "failed", output: `Error overwriting ${operation.path}: ${String(err)}` };
     }
@@ -1048,7 +1124,7 @@ var WorkspaceEditor = class {
   async deleteFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      if (!existsSync6(targetPath)) {
+      if (!existsSync7(targetPath)) {
         return { status: "failed", output: "Error: file not found at path " + targetPath };
       }
       await rm(targetPath, { force: true });
@@ -1089,11 +1165,11 @@ function pickExistingSkill(candidates) {
   }
   return null;
 }
-async function requiredSkillForOperation(path9, type) {
+async function requiredSkillForOperation(path10, type) {
   if (type === "delete_file") {
     return null;
   }
-  const p = normalizedPath(path9);
+  const p = normalizedPath(path10);
   const read = await getSkillsRead();
   if (p.includes("/resources/") || p.startsWith("resources/") || p.endsWith("resources.ts") || p.endsWith("resources.js")) {
     if (!read.includes("automatic-apis")) {
@@ -1148,7 +1224,23 @@ async function execute11(operation) {
     if (needed) {
       const content = await execute10({ skill: needed });
       console.error(`Understanding ${needed} is necessary before applying this patch.`);
-      return { status: "failed, skill guarded", output: content };
+      return {
+        status: "skill_required",
+        output: `apply_patch blocked: you must understand the "${needed}" skill before writing to "${operation.path}".
+
+REQUIRED NEXT STEP: Call apply_patch again with the EXACT same arguments:
+  type="${operation.type}", path="${operation.path}", diff=<same diff as before>
+
+PROHIBITED \u2014 do NOT attempt any of the following to work around this:
+  - Use the shell tool to write or create files
+  - Call set_patch_auto_approve or set_shell_auto_approve
+  - Use any other workaround
+
+Read the skill content below, then retry apply_patch immediately.
+
+--- Skill: ${needed} ---
+${content}`
+      };
     }
     switch (operation.type) {
       case "create_file":
@@ -1179,7 +1271,12 @@ async function execute11(operation) {
 function createApplyPatchTool() {
   return tool11({
     name: "apply_patch",
-    description: "Applies a patch (create, update, or delete a file) to the workspace.",
+    description: `Applies a patch (create, update, or delete a file) to the workspace.
+
+SKILL GUARD: Some file paths require reading a specific Harper skill before writing. If this tool returns status "skill_required", you MUST:
+  1. Read the skill content included in the response carefully.
+  2. Call apply_patch again with the EXACT same type, path, and diff arguments.
+Do NOT use shell, set_patch_auto_approve, set_shell_auto_approve, or any other workaround to bypass this requirement.`,
     parameters: ApplyPatchParameters,
     needsApproval,
     execute: execute11
@@ -1193,9 +1290,9 @@ import { z as z12 } from "zod";
 var ToolParameters11 = z12.object({
   path: z12.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
 });
-async function execute12({ path: path9 }) {
+async function execute12({ path: path10 }) {
   try {
-    const target = resolvePath(trackedState.cwd, path9);
+    const target = resolvePath(trackedState.cwd, path10);
     const stat = statSync(target);
     if (!stat.isDirectory()) {
       return `Path is not a directory: ${target}`;
@@ -1296,7 +1393,7 @@ var findTool = tool14({
 // tools/files/readDirTool.ts
 import { tool as tool15 } from "@openai/agents";
 import { readdir } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { z as z15 } from "zod";
 var ToolParameters14 = z15.object({
   directoryName: z15.string().describe("The name of the directory to read.")
@@ -1309,7 +1406,7 @@ var readDirTool = tool15({
     try {
       const resolvedPath = resolvePath(trackedState.cwd, directoryName);
       const files = await readdir(resolvedPath, "utf8");
-      return files.filter((file) => !isIgnored(path5.join(resolvedPath, file)));
+      return files.filter((file) => !isIgnored(path6.join(resolvedPath, file)));
     } catch (error) {
       return `Error reading directory: ${error}`;
     }
@@ -1365,7 +1462,7 @@ var readFileTool = tool16({
 import { tool as tool17 } from "@openai/agents";
 import { exec } from "child_process";
 import { unlink, writeFile as writeFile2 } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 import { promisify as promisify3 } from "util";
 import { z as z17 } from "zod";
 var execAsync = promisify3(exec);
@@ -1408,7 +1505,7 @@ async function needsApproval2(runContext, parameters, callId) {
 async function execute14({ code, language }) {
   const extension = language === "javascript" ? "js" : "py";
   const interpreter = language === "javascript" ? "node" : "python3";
-  const tempFile = path6.join(trackedState.cwd, `.temp_code_${Date.now()}.${extension}`);
+  const tempFile = path7.join(trackedState.cwd, `.temp_code_${Date.now()}.${extension}`);
   try {
     await writeFile2(tempFile, code, "utf8");
     const { stdout, stderr } = await execAsync(`${interpreter} ${tempFile}`);
@@ -1467,7 +1564,7 @@ import { tool as tool19 } from "@openai/agents";
 import { z as z19 } from "zod";
 
 // utils/files/updateEnv.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname4, join as join7 } from "path";
 function updateEnv(key, value) {
@@ -1475,14 +1572,14 @@ function updateEnv(key, value) {
   process.env[key] = normalizedValue;
   const topLevelEnvPath = join7(homedir3(), ".harper", "harper-agent-env");
   const localEnvPath = join7(trackedState.cwd, ".env");
-  const envPath = existsSync7(topLevelEnvPath) || !existsSync7(localEnvPath) ? topLevelEnvPath : localEnvPath;
+  const envPath = existsSync8(topLevelEnvPath) || !existsSync8(localEnvPath) ? topLevelEnvPath : localEnvPath;
   const dir = dirname4(envPath);
-  if (!existsSync7(dir)) {
+  if (!existsSync8(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   let envContent = "";
-  if (existsSync7(envPath)) {
-    envContent = readFileSync5(envPath, "utf8");
+  if (existsSync8(envPath)) {
+    envContent = readFileSync6(envPath, "utf8");
   }
   const regex = new RegExp(`^${key}=.*`, "m");
   if (regex.test(envContent)) {
@@ -2002,7 +2099,7 @@ var checkHarperStatusTool = tool30({
 // tools/harper/createNewHarperApplicationTool.ts
 import { tool as tool31 } from "@openai/agents";
 import { execSync as execSync3 } from "child_process";
-import path7 from "path";
+import path8 from "path";
 import { z as z31 } from "zod";
 
 // utils/package/buildHarperCreateCommand.ts
@@ -2061,8 +2158,8 @@ async function execute16({ directoryName, template }) {
   const currentCwd = trackedState.cwd;
   const resolvedPath = resolvePath(currentCwd, directoryName);
   const isCurrentDir = resolvedPath === currentCwd;
-  const executionCwd = isCurrentDir ? resolvedPath : path7.dirname(resolvedPath);
-  const appName = isCurrentDir ? "." : path7.basename(resolvedPath);
+  const executionCwd = isCurrentDir ? resolvedPath : path8.dirname(resolvedPath);
+  const appName = isCurrentDir ? "." : path8.basename(resolvedPath);
   try {
     const pm = pickPreferredPackageManager();
     const { cmd, label } = buildCreateCommand(pm, appName, template);
@@ -2223,14 +2320,14 @@ var hitHarperAPITool = tool35({
     }
     return false;
   },
-  async execute({ path: path9 = "/openapi", port, method = "GET", body }) {
+  async execute({ path: path10 = "/openapi", port, method = "GET", body }) {
     try {
       const effectivePort = port ?? (harperProcess.running ? harperProcess.httpPort : void 0);
       if (!effectivePort) {
         return `Error: No Harper application is currently running and no port was specified.`;
       }
       const response = await fetch(
-        `http://localhost:${effectivePort}${path9.startsWith("/") ? "" : "/"}${path9}`,
+        `http://localhost:${effectivePort}${path10.startsWith("/") ? "" : "/"}${path10}`,
         {
           method,
           headers: body ? { "Content-Type": "application/json" } : {},
@@ -2270,7 +2367,7 @@ var readHarperLogsTool = tool36({
 
 // tools/harper/startHarperTool.ts
 import { tool as tool37 } from "@openai/agents";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { basename, resolve } from "path";
 import { z as z37 } from "zod";
 
@@ -2297,7 +2394,7 @@ var startHarperTool = tool37({
     try {
       let effectiveDirectory = directoryName;
       const candidatePath = resolve(process.cwd(), directoryName);
-      if (!existsSync8(candidatePath)) {
+      if (!existsSync9(candidatePath)) {
         const cwd = process.cwd();
         if (basename(cwd) === directoryName) {
           effectiveDirectory = cwd;
@@ -2625,7 +2722,7 @@ Stack: ${String(err.stack).split("\n").slice(0, 8).join("\n")}` : "";
 
 // utils/sessions/DiskSession.ts
 import { MemorySession } from "@openai/agents";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir2, readFile as readFile5, rename, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname8 } from "path";
 var DiskSession = class extends MemorySession {
@@ -2676,7 +2773,7 @@ var DiskSession = class extends MemorySession {
     }
   }
   async loadStorage() {
-    if (existsSync9(this.filePath)) {
+    if (existsSync10(this.filePath)) {
       try {
         const data = await readFile5(this.filePath, "utf-8");
         const parsed = JSON.parse(data);
@@ -2694,7 +2791,7 @@ var DiskSession = class extends MemorySession {
     const storage = await this.loadStorage();
     update(storage);
     const dir = dirname8(this.filePath);
-    if (!existsSync9(dir)) {
+    if (!existsSync10(dir)) {
       await mkdir2(dir, { recursive: true });
     }
     const data = JSON.stringify(storage, null, 2);
@@ -3810,7 +3907,7 @@ async function runAgentForOnePass(agent, session, input, controller, isPrompt) {
 }
 
 // agent/AgentManager.ts
-var AgentManager = class {
+var AgentManager = class _AgentManager {
   isInitialized = false;
   controller = null;
   queuedUserInputs = [];
@@ -3818,17 +3915,20 @@ var AgentManager = class {
   agent = null;
   session = null;
   initialMessages = [];
-  async initialize() {
-    if (this.isInitialized) {
-      return;
-    }
-    this.agent = new Agent3({
+  static instantiateAgent(tools) {
+    return new Agent3({
       name: "Harper Agent",
       model: isOpenAIModel(trackedState.model) ? trackedState.model : getModel(trackedState.model),
       modelSettings: getModelSettings(trackedState.model),
       instructions: readAgentSkillsRoot() || defaultInstructions(),
-      tools: createTools()
+      tools
     });
+  }
+  async initialize() {
+    if (this.isInitialized) {
+      return;
+    }
+    this.agent = _AgentManager.instantiateAgent(createTools());
     this.session = createSession(trackedState.sessionPath);
     try {
       const plan = await this.session?.getPlanState?.();
@@ -4923,7 +5023,7 @@ function PlanView() {
 
 // ink/components/SettingsView.tsx
 import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
-import path8 from "path";
+import path9 from "path";
 import { useEffect as useEffect6, useMemo as useMemo9, useState as useState11 } from "react";
 
 // ink/contexts/SettingsContext.tsx
@@ -5065,8 +5165,8 @@ function SettingsView({ isDense = false }) {
     if (!sessionPath) {
       return null;
     }
-    const relative = path8.relative(cwd, sessionPath);
-    if (!relative.startsWith("..") && !path8.isAbsolute(relative)) {
+    const relative = path9.relative(cwd, sessionPath);
+    if (!relative.startsWith("..") && !path9.isAbsolute(relative)) {
       return `./${relative}`;
     }
     return sessionPath;
@@ -6476,13 +6576,13 @@ function warnAndPersistRedirect(original, envKey, replacement, reason) {
 import chalk5 from "chalk";
 
 // utils/package/getOwnPackageJson.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { join as join11 } from "path";
-import { fileURLToPath } from "url";
-var __dirname = fileURLToPath(new URL(".", import.meta.url));
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = fileURLToPath2(new URL(".", import.meta.url));
 function getOwnPackageJson() {
   try {
-    const packageContents = readFileSync6(join11(__dirname, "../package.json"), "utf8");
+    const packageContents = readFileSync7(join11(__dirname2, "../package.json"), "utf8");
     return JSON.parse(packageContents);
   } catch {
     return { name: "@harperfast/agent", version: "0.0.0" };
@@ -6686,16 +6786,16 @@ function parseArgs() {
 
 // utils/envLoader.ts
 import dotenv from "dotenv";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join12 } from "path";
 function loadEnv() {
   const topLevelEnvPath = join12(homedir4(), ".harper", "harper-agent-env");
   const localEnvPath = join12(process.cwd(), ".env");
-  if (existsSync10(topLevelEnvPath)) {
+  if (existsSync11(topLevelEnvPath)) {
     dotenv.config({ path: topLevelEnvPath, quiet: true });
   }
-  if (existsSync10(localEnvPath)) {
+  if (existsSync11(localEnvPath)) {
     dotenv.config({ path: localEnvPath, override: true, quiet: true });
   }
 }

package/dist/schema.graphql

@@ -0,0 +1,245 @@
+"""
+A flexible JSON-like value.
+Accepts objects, arrays, strings, numbers, booleans, or null.
+Useful for schemaless or mixed content.
+"""
+scalar Any
+
+"""
+Arbitrary-precision integer for values larger than 32-bit/64-bit ranges.
+Input may be provided as a JSON number or string; tooling may return it as a
+string to avoid precision loss. Use `Long` for 64-bit integers when possible.
+"""
+scalar BigInt
+
+"""
+Binary large object. Represents binary data such as images or files.
+Typically encoded as Base64 in JSON.
+"""
+scalar Blob
+
+"""
+true or false
+"""
+scalar Boolean
+
+"""
+Raw bytes. Typically encoded/transported as Base64 in JSON.
+Use when you need deterministic binary data that is not a large file.
+"""
+scalar Bytes
+
+"""
+Date/time scalar. Recommended format: RFC 3339/ISO-8601 (e.g.,
+"2025-12-02T19:44:00Z"). Represents an absolute timestamp.
+"""
+scalar Date
+
+"""
+A signed double-precision floating-point value
+"""
+scalar Float
+
+"""
+ID (serialized as a String): A unique identifier that's often used to refetch an
+object or as the key for a cache. Although it's serialized as a String, an ID is
+not intended to be human‐readable.
+"""
+scalar ID
+
+"""
+A signed 32‐bit integer
+"""
+scalar Int
+
+"""
+64-bit signed integer. Some clients may serialize values as strings to
+preserve precision across environments.
+"""
+scalar Long
+
+"""
+A UTF‐8 character sequence
+"""
+scalar String
+
+"""
+Attach to an object type to persist it as a table.
+
+Example:
+```
+type Post @table(table: "posts", database: "blog") {
+id: ID @primaryKey
+title: String @indexed(type: "fulltext")
+body: String
+createdAt: Date @createdTime
+updatedAt: Date @updatedTime
+}
+```
+"""
+directive @table(
+    """
+    Explicit table name. If omitted, a sensible default derived from the
+    type name will be used.
+    """
+    table: String
+    """
+    Logical database/namespace to place this table in.
+    """
+    database: String
+    """
+    Default time-to-live (TTL) for records in seconds. Use a positive value to
+    enable automatic expiration; omit or set to 0 to disable.
+    """
+    expiration: Int
+    """
+    Enable auditing for create/update/delete operations.
+    """
+    audit: Boolean
+    """
+    The amount of time after expiration before a record can be evicted (defaults to zero).
+    """
+    eviction: Int
+    """
+    The interval for scanning for expired records (defaults to one quarter of the
+    total of expiration and eviction).
+    """
+    scanInterval: Int
+    """
+    By default, all tables within a replicated database will be replicated. Transactions
+    are replicated atomically, which may involve data across multiple tables. However,
+    you can also configure replication for individual tables, and disable and exclude
+    replication for specific tables in a database by setting replicate to false in the
+    table definition.
+    """
+    replicate: Boolean
+) on OBJECT
+
+"""
+Expose the table via the REST API. When applied to a `@table` type, routes are
+generated using the type name or the provided alias.
+"""
+directive @export(
+    """
+    Optional alias to use for REST endpoints. If omitted, the type/table name is
+    used.
+    """
+    name: String
+    """
+    REST support is, by default, turned on for any exported resource. You may specify
+    false to disable this automatic API support.
+    """
+    rest: Boolean
+    """
+    MQTT support is, by default, turned on for any exported resource. You may specify
+    false to disable this automatic API support.
+    """
+    mqtt: Boolean
+) on OBJECT
+"""
+As a NoSQL database, HarperDB supports heterogeneous records (also referred to as
+documents), so you can freely specify additional properties on any record. If you
+do want to restrict the records to only defined properties, you can always do that
+by adding the sealed directive.
+"""
+directive @sealed on OBJECT
+
+"""
+Marks the primary key field for the table. The value must be unique per record
+and is used for lookups, updates, and relationships.
+"""
+directive @primaryKey on FIELD_DEFINITION
+
+"""
+Allows enumeration over a computed field, causing it to be included in serialized responses. (Non-computed fields are always enumerable, and don't need to be flagged.)
+"""
+directive @enumerable on FIELD_DEFINITION
+
+"""
+Flags the field as containing the expiration time of the entry.
+"""
+directive @expiresAt on FIELD_DEFINITION
+
+"""
+Permit access to the field based on the named roles, only.
+"""
+directive @allow(role: String) on FIELD_DEFINITION
+
+"""
+Create an index for the annotated field. Supports traditional and vector/ANN
+index types.
+"""
+directive @indexed(
+    """
+    Optional index type, e.g. "HNSW"
+    """
+    type: String
+    """
+    Distance metric for vector indexes (e.g., "euclidean", "cosine").
+    Ignored for non-vector index types.
+    """
+    distance: String
+    """
+    Construction effort/recall parameter (HNSW). Higher values improve recall at
+    the cost of build time and memory.
+    """
+    efConstruction: Int
+    """
+    Maximum number of bi-directional connections per node (HNSW).
+    Typical range: 4–64.
+    """
+    M: Int
+    """
+    Routing optimization level for search graphs (implementation-specific).
+    """
+    optimizeRouting: Int
+    """
+    Additional multiplier for graph links (implementation-specific).
+    """
+    mL: Int
+    """
+    Search-time effort/recall parameter used during construction (implementation-
+    specific). Larger values typically yield better accuracy.
+    """
+    efConstructionSearch: Int
+) on FIELD_DEFINITION
+
+"""
+Define a derived field whose value is computed from other fields.
+Useful for denormalized or presentation-friendly data.
+"""
+directive @computed(
+    """
+    Computation expression or reference describing how to derive this field from
+    other fields (engine-specific syntax).
+    """
+    from: String
+    """
+    Increment when the computation changes to trigger recomputation.
+    """
+    version: Int
+) on FIELD_DEFINITION
+"""
+Automatically sets this field to the record's creation timestamp. The server
+assigns the value on insert.
+"""
+directive @createdTime on FIELD_DEFINITION
+"""
+Automatically updates this field to the current timestamp whenever the record
+is updated.
+"""
+directive @updatedTime on FIELD_DEFINITION
+"""
+Declares a relationship to another record or records.
+Use on fields that should resolve to related entities by ID.
+"""
+directive @relationship(
+    """
+    Name of field in THIS table containing foreign key(s) (for one-to-many or many-to-many).
+    """
+    from: String
+    """
+    Name of field in OTHER table containing foreign key (for one-to-one or many-to-one).
+    """
+    to: String
+) on FIELD_DEFINITION

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@harperfast/agent",
 	"description": "AI to help you with Harper app management",
-	"version": "0.16.0",
+	"version": "0.16.2",
 	"main": "dist/agent.js",
 	"repository": "github:HarperFast/harper-agent",
 	"bugs": {
@@ -11,7 +11,7 @@
 	"scripts": {
 		"dev": "tsup agent.ts --format esm --clean --dts --watch --external puppeteer",
 		"link": "npm run build && npm link",
-		"build": "tsup agent.ts --format esm --clean --dts --external puppeteer",
+		"build": "tsup agent.ts --format esm --clean --dts --external puppeteer && cp node_modules/harperdb/schema.graphql dist/",
 		"commitlint": "commitlint --edit",
 		"start": "node ./dist/agent.js",
 		"lint": "oxlint --format stylish .",
@@ -54,6 +54,7 @@
 		"chalk": "^5.6.2",
 		"cross-spawn": "^7.0.6",
 		"dotenv": "^17.2.4",
+		"graphql": "^16.13.1",
 		"ink": "^6.7.0",
 		"ink-stepper": "^0.2.1",
 		"ink-task-list": "^2.0.0",