@darkhorseprojects/circuitry 0.2.20 → 0.2.21

package/dist/index.d.ts

@@ -8,4 +8,3 @@ export * from "./bundle";
 export * from "./runtime";
 export * from "./host";
 export * from "./tools";
-export * from "./node";

package/dist/index.js

@@ -176,7 +176,7 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
     graph && typeof graph === "object" && !Array.isArray(graph) ? graph : void 0
   );
   const errors = [];
-  const addError = (code, message, path3) => errors.push({ code, message, ...path3 ? { path: path3 } : {} });
+  const addError = (code, message, path2) => errors.push({ code, message, ...path2 ? { path: path2 } : {} });
   if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
     addError("invalid_graph", "Circuitry graph must be an object");
     return { ok: false, errors, standard: resolvedStandard };
@@ -253,19 +253,19 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
   }
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const path2 = [];
+  const path = [];
   let cycleMessage = "";
   const visit = (id) => {
     if (cycleMessage) return;
     if (visiting.has(id)) {
-      cycleMessage = [...path2.slice(path2.indexOf(id)), id].join(" -> ");
+      cycleMessage = [...path.slice(path.indexOf(id)), id].join(" -> ");
       return;
     }
     if (visited.has(id)) return;
     visiting.add(id);
-    path2.push(id);
+    path.push(id);
     for (const next of adjacency.get(id) || []) visit(next);
-    path2.pop();
+    path.pop();
     visiting.delete(id);
     visited.add(id);
   };
@@ -315,15 +315,15 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
       }
       continue;
     }
-    const checkString = (target, subject, id, match, path3) => {
+    const checkString = (target, subject, id, match, path2) => {
       const value = getField(subject, match.field);
       const text = typeof value === "string" ? value : "";
       const includes = text.includes(match.value);
       if (rule.rule === "require-string" && !includes) {
-        addError("missing_required_string", `${target} ${id} field ${match.field} must include string: ${match.value}`, path3);
+        addError("missing_required_string", `${target} ${id} field ${match.field} must include string: ${match.value}`, path2);
       }
       if (rule.rule === "reject-string" && includes) {
-        addError("rejected_string", `${target} ${id} field ${match.field} must not include string: ${match.value}`, path3);
+        addError("rejected_string", `${target} ${id} field ${match.field} must not include string: ${match.value}`, path2);
       }
     };
     for (const match of rule.graph || []) checkString("graph", normalized, "<root>", match, fieldPath(match.field));
@@ -1086,237 +1086,6 @@ var createCircuitryTools = (host) => [
   createCircuitryRunGraphTool(host),
   createCircuitryValidateGraphTool(host)
 ];
-
-// src/node.ts
-import { access, readFile, writeFile } from "node:fs/promises";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-var loadPiSDK = async () => {
-  const possiblePaths = [
-    path.join(process.cwd(), "node_modules/@earendil-works/pi-coding-agent/dist/index.js"),
-    path.join(os.homedir(), ".npm-global/lib/node_modules/@earendil-works/pi-coding-agent/dist/index.js")
-  ];
-  for (const modulePath of possiblePaths) {
-    if (fs.existsSync(modulePath)) {
-      return await import(modulePath);
-    }
-  }
-  return await import("@earendil-works/pi-coding-agent");
-};
-var extractAssistantText = (message) => {
-  if (!message || message.role !== "assistant") return "";
-  if (typeof message.content === "string") return message.content;
-  if (!Array.isArray(message.content)) return "";
-  return message.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
-};
-var withTimeout = async (promise, timeoutMs) => {
-  let timeout;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timeout = setTimeout(
-          () => reject(new Error(`Pi SDK request timed out after ${timeoutMs}ms`)),
-          timeoutMs
-        );
-      })
-    ]);
-  } finally {
-    clearTimeout(timeout);
-  }
-};
-var runNodeWithPiSDK = async ({
-  model,
-  prompt,
-  images = [],
-  tools = [],
-  thinkingLevel = "off"
-}) => {
-  let sdk;
-  try {
-    sdk = await loadPiSDK();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      [
-        "Circuitry could not load the Pi SDK package for execution.",
-        "Ensure @earendil-works/pi-coding-agent is installed.",
-        message
-      ].join("\n")
-    );
-  }
-  const { AuthStorage, ModelRegistry, SessionManager, createAgentSession } = sdk;
-  const authStorage = AuthStorage.create();
-  const modelRegistry = ModelRegistry.create(authStorage);
-  const [provider, ...modelParts] = String(model || "").split("/");
-  const modelId = modelParts.join("/");
-  const available = await modelRegistry.getAvailable();
-  const selectedModel = (provider && modelId ? modelRegistry.find(provider, modelId) : void 0) || available.find((entry) => {
-    if (!modelId) return false;
-    return `${entry.provider}/${entry.id}` === `${provider}/${modelId}` || entry.id === modelId;
-  }) || available[0];
-  if (!selectedModel) {
-    throw new Error("No Pi SDK models are available. Configure ~/.pi/agent/auth.json");
-  }
-  const { session } = await createAgentSession({
-    model: selectedModel,
-    thinkingLevel,
-    sessionManager: SessionManager.inMemory(),
-    authStorage,
-    modelRegistry
-  });
-  session.setActiveToolsByName(Array.isArray(tools) ? tools.map((tool) => String(tool)) : []);
-  let output = "";
-  const unsubscribe = session.subscribe((event) => {
-    if ((event.type === "message_update" || event.type === "message_end") && event.message?.role === "assistant") {
-      output = extractAssistantText(event.message);
-    }
-    if (event.type === "agent_end" && Array.isArray(event.messages)) {
-      const assistantMessage = [...event.messages].reverse().find((message) => message.role === "assistant");
-      output = extractAssistantText(assistantMessage);
-    }
-  });
-  try {
-    const promptImages = images.filter((image) => image?.mediaType && image?.data).map((image) => ({
-      type: "image",
-      source: { type: "base64", mediaType: image.mediaType, data: image.data }
-    }));
-    await withTimeout(session.prompt(prompt, { images: promptImages }), 18e4);
-    return { output: output.trim() };
-  } finally {
-    unsubscribe();
-    session.dispose();
-  }
-};
-var defaultFilename = "graph.circuitry.yaml";
-var NodeCircuitryHost = class {
-  resolveGraphFile(filename) {
-    return path.resolve(
-      process.cwd(),
-      filename || process.env.CIRCUITRY_GRAPH || defaultFilename
-    );
-  }
-  runFileFor(filename) {
-    return `${filename}.run.json`;
-  }
-  async exists(filename) {
-    try {
-      await access(filename);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  parseIssue(error, filename) {
-    return {
-      code: "parse_error",
-      message: error instanceof Error ? error.message : String(error),
-      path: [filename]
-    };
-  }
-  parseGraphForValidation(text, filename, standard) {
-    try {
-      return {
-        graph: parseCircuitryText(text || "", filename, standard, {
-          validate: false
-        })
-      };
-    } catch (error) {
-      return { error: this.parseIssue(error, filename) };
-    }
-  }
-  async readGraphFile(filename) {
-    const graphFile = this.resolveGraphFile(filename);
-    const text = await readFile(graphFile, "utf8");
-    const graph = parseCircuitryText(text, graphFile);
-    return { graphFile, text, graph };
-  }
-  async readGraph(input = {}) {
-    const { graphFile, text, graph } = await this.readGraphFile(input.filename);
-    const lastRunFile = this.runFileFor(graphFile);
-    const lastRun = await this.exists(lastRunFile) ? JSON.parse(await readFile(lastRunFile, "utf8")) : void 0;
-    return { filename: graphFile, graph, text, lastRun };
-  }
-  async validateGraph(input) {
-    if (input.graph)
-      return validateCircuitryGraphWithStandard(input.graph, input.standard);
-    const filename = input.filename || defaultFilename;
-    const parsed = this.parseGraphForValidation(input.text, filename, input.standard);
-    if (parsed.error) {
-      return {
-        ok: false,
-        errors: [parsed.error],
-        standard: validateCircuitryGraphWithStandard({}, input.standard).standard
-      };
-    }
-    return validateCircuitryGraphWithStandard(parsed.graph, input.standard);
-  }
-  async writeGraph(input) {
-    const graphFile = this.resolveGraphFile(input.filename);
-    const parsed = input.graph ? { graph: input.graph } : this.parseGraphForValidation(
-      input.text,
-      input.filename || graphFile,
-      input.standard
-    );
-    if (!parsed.graph)
-      throw new Error(`Invalid Circuitry graph:
-${parsed.error?.message}`);
-    const validation = await this.validateGraph({
-      graph: parsed.graph,
-      standard: input.standard
-    });
-    if (validation.errors.length)
-      throw new Error(
-        `Invalid Circuitry graph:
-${validation.errors.map((e) => e.message).join("\n")}`
-      );
-    await writeFile(
-      graphFile,
-      stringifyCircuitryText(parsed.graph, graphFile),
-      "utf8"
-    );
-    return {
-      filename: graphFile,
-      graph: parsed.graph,
-      mode: "replace"
-    };
-  }
-  async runGraph(input = {}) {
-    const source = input.source || (input.text ? "text" : "current");
-    const graphFile = this.resolveGraphFile(input.filename);
-    const parsed = source === "text" ? this.parseGraphForValidation(
-      input.text,
-      input.filename || graphFile,
-      input.standard
-    ) : { graph: (await this.readGraphFile(input.filename)).graph };
-    if (!parsed.graph)
-      throw new Error(`Invalid Circuitry graph:
-${parsed.error?.message}`);
-    const validation = await this.validateGraph({
-      graph: parsed.graph,
-      standard: input.standard
-    });
-    if (validation.errors.length)
-      throw new Error(
-        `Invalid Circuitry graph:
-${validation.errors.map((e) => e.message).join("\n")}`
-      );
-    const runItems = await runCircuitryGraphExecution({
-      graph: parsed.graph,
-      selectedNodeId: input.selectedNodeId,
-      executeNode: (req) => runNodeWithPiSDK(req)
-    });
-    const result = { completedAt: (/* @__PURE__ */ new Date()).toISOString(), runItems };
-    if (source !== "text")
-      await writeFile(
-        this.runFileFor(graphFile),
-        JSON.stringify(result, null, 2),
-        "utf8"
-      );
-    return result;
-  }
-};
 export {
   BUNDLE_MIME,
   CIRCUITRY_AGENT_PRESET_DIRS,
@@ -1327,7 +1096,6 @@ export {
   DEFAULT_CIRCUITRY_VALIDATION_RULES,
   DEFAULT_CIRCUITRY_VALIDATION_STANDARD,
   DEFAULT_MAX_PARALLEL_RUNS,
-  NodeCircuitryHost,
   applyAgentPresets,
   buildCircuitryExecutionGraph,
   buildSimulationGraph,
@@ -1353,7 +1121,6 @@ export {
   runCircuitryGraphExecution,
   runDependencySimulation,
   runGraphExecution,
-  runNodeWithPiSDK,
   standardSchema,
   stringifyCircuitryJson,
   stringifyCircuitryText,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkhorseprojects/circuitry",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",