@praesidia/neurogent 0.1.0

package/dist/chunk-JBDXA3BS.js

@@ -0,0 +1,214 @@
+import {
+  executeAgent
+} from "./chunk-ZC65T52L.js";
+
+// src/types.ts
+import { z } from "zod";
+import { parse as parseYaml } from "yaml";
+var neuroAgentSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  author: z.string(),
+  license: z.string(),
+  capabilities: z.array(z.string()),
+  model: z.object({
+    provider: z.string(),
+    name: z.string(),
+    temperature: z.number().optional().default(0.7),
+    max_tokens: z.number().optional().default(4096)
+  }),
+  memory: z.object({
+    type: z.enum(["conversation-buffer", "redis", "none"]),
+    max_messages: z.number().optional().default(50)
+  }).optional().default({ type: "conversation-buffer" }),
+  tools: z.array(
+    z.object({
+      name: z.string(),
+      description: z.string(),
+      type: z.enum(["inline", "mcp"]).optional().default("inline"),
+      mcp_server: z.string().optional()
+    })
+  ).optional().default([]),
+  praesidia: z.object({
+    policy: z.string().optional(),
+    enforce_on: z.array(z.string()).optional().default([])
+  }).optional(),
+  sub_agents: z.array(
+    z.object({
+      name: z.string(),
+      description: z.string(),
+      endpoint: z.string()
+    })
+  ).optional().default([]),
+  auth: z.object({
+    type: z.enum(["bearer", "none", "oauth2"])
+  }).optional().default({ type: "none" }),
+  endpoint: z.string().optional().default("/a2a")
+});
+function parseAgentConfig(yamlContent) {
+  const raw = parseYaml(yamlContent);
+  return neuroAgentSchema.parse(raw);
+}
+function compileToAgentCard(config, praesidiaHash) {
+  return {
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    author: config.author,
+    license: config.license,
+    capabilities: config.capabilities,
+    tools: config.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      type: t.type,
+      mcp_server: t.mcp_server
+    })),
+    endpoints: {
+      message: `${config.endpoint}/message`,
+      tasks: `${config.endpoint}/tasks`
+    },
+    sub_agents: config.sub_agents.map((sa) => ({
+      name: sa.name,
+      description: sa.description,
+      endpoint: sa.endpoint
+    })),
+    "x-praesidia-policy-hash": praesidiaHash
+  };
+}
+
+// src/zeroclaw/runtime.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+function createAgentServer(agent, port, globalModel) {
+  const app = new Hono();
+  const tasks = /* @__PURE__ */ new Map();
+  const history = [];
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let serverClose = null;
+  app.get("/health", (c) => {
+    return c.json({
+      status: "ok",
+      agent: agent.name,
+      role: agent.role,
+      port,
+      uptime: Math.floor((Date.now() - new Date(startedAt).getTime()) / 1e3),
+      tasks: tasks.size
+    });
+  });
+  app.get("/.well-known/agent.json", (c) => {
+    return c.json({
+      name: agent.name,
+      version: "1.0.0",
+      description: agent.role,
+      capabilities: agent.expertise,
+      endpoints: {
+        message: `http://localhost:${port}/webhook`,
+        tasks: `http://localhost:${port}/a2a/tasks`
+      }
+    });
+  });
+  app.post("/webhook", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const message = body.message ?? body.text ?? body.prompt ?? "";
+    const taskId = `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const stream = body.stream ?? false;
+    if (!message) {
+      return c.json({ error: "message field required" }, 400);
+    }
+    const record = {
+      taskId,
+      state: "WORKING",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    tasks.set(taskId, record);
+    if (stream) {
+      const encoder = new TextEncoder();
+      const readable = new ReadableStream({
+        async start(controller) {
+          try {
+            let fullResponse = "";
+            for await (const chunk of executeAgent(agent, message, history, globalModel)) {
+              fullResponse += chunk;
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify({ chunk })}
+
+`));
+            }
+            history.push({ role: "user", content: message });
+            history.push({ role: "assistant", content: fullResponse });
+            if (history.length > 20) history.splice(0, history.length - 20);
+            record.state = "COMPLETED";
+            record.result = fullResponse;
+            record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ done: true, taskId })}
+
+`));
+          } catch (err) {
+            record.state = "FAILED";
+            record.error = String(err);
+            record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: record.error })}
+
+`));
+          }
+          controller.close();
+        }
+      });
+      return new Response(readable, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "X-Task-Id": taskId
+        }
+      });
+    }
+    try {
+      let fullResponse = "";
+      for await (const chunk of executeAgent(agent, message, history, globalModel)) {
+        fullResponse += chunk;
+      }
+      history.push({ role: "user", content: message });
+      history.push({ role: "assistant", content: fullResponse });
+      if (history.length > 20) history.splice(0, history.length - 20);
+      record.state = "COMPLETED";
+      record.result = fullResponse;
+      record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return c.json({ taskId, state: "COMPLETED", result: fullResponse });
+    } catch (err) {
+      record.state = "FAILED";
+      record.error = String(err);
+      record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return c.json({ taskId, state: "FAILED", error: record.error }, 500);
+    }
+  });
+  app.get("/a2a/tasks/:taskId", (c) => {
+    const taskId = c.req.param("taskId");
+    const task = tasks.get(taskId);
+    if (!task) return c.json({ error: "Task not found" }, 404);
+    return c.json(task);
+  });
+  app.get("/a2a/tasks", (c) => {
+    return c.json([...tasks.values()].slice(-20));
+  });
+  return {
+    async start() {
+      return new Promise((resolve) => {
+        const server = serve({ fetch: app.fetch, port }, () => {
+          resolve({ agent, port, url: `http://localhost:${port}`, startedAt });
+        });
+        serverClose = () => server.close();
+      });
+    },
+    stop() {
+      serverClose?.();
+    }
+  };
+}
+
+export {
+  neuroAgentSchema,
+  parseAgentConfig,
+  compileToAgentCard,
+  createAgentServer
+};

package/dist/chunk-VPHKQCPP.js

@@ -0,0 +1,49 @@
+// src/shell/config/schema.ts
+import { z } from "zod";
+var AgentModelSchema = z.object({
+  provider: z.enum(["openai", "anthropic", "ollama"]).default("openai"),
+  name: z.string(),
+  max_tokens: z.number().int().positive().default(1024),
+  temperature: z.number().min(0).max(2).default(0.7),
+  base_url: z.string().url().optional()
+});
+var AgentSchema = z.object({
+  id: z.string().regex(/^[a-z][a-z0-9_-]*$/, "Agent id must be lowercase alphanumeric with _ or -"),
+  name: z.string().min(1),
+  role: z.string().min(1),
+  emoji: z.string().default("\u{1F916}"),
+  color: z.enum([
+    "black",
+    "red",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "cyan",
+    "white",
+    "blackBright",
+    "redBright",
+    "greenBright",
+    "yellowBright",
+    "blueBright",
+    "magentaBright",
+    "cyanBright",
+    "whiteBright",
+    "gray",
+    "grey"
+  ]).default("white"),
+  expertise: z.array(z.string().min(1)).min(1, "At least one expertise keyword required"),
+  system_prompt: z.string().min(1),
+  model: AgentModelSchema.optional()
+});
+var ShellYamlSchema = z.object({
+  shell: z.object({
+    name: z.string().default("Neuro Shell")
+  }).default({ name: "Neuro Shell" }),
+  model: AgentModelSchema.optional(),
+  agents: z.array(AgentSchema).min(1, "At least one agent required")
+});
+
+export {
+  ShellYamlSchema
+};

package/dist/chunk-ZC65T52L.js

@@ -0,0 +1,255 @@
+// src/zeroclaw/client.ts
+import * as fs from "fs";
+import * as path from "path";
+var RUNTIME_FILE = path.join(process.cwd(), ".neurogent", "runtime.json");
+function loadRuntime() {
+  try {
+    const raw = fs.readFileSync(RUNTIME_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveRuntime(reg) {
+  const dir = path.dirname(RUNTIME_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(RUNTIME_FILE, JSON.stringify(reg, null, 2));
+}
+function clearRuntime() {
+  try {
+    fs.unlinkSync(RUNTIME_FILE);
+  } catch {
+  }
+}
+function getAgentUrl(agentId) {
+  const runtime = loadRuntime();
+  if (!runtime) return null;
+  const entry = runtime.agents.find((a) => a.id === agentId);
+  return entry?.url ?? null;
+}
+async function pingAgent(url) {
+  try {
+    const res = await fetch(`${url}/health`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return { alive: false, error: `HTTP ${res.status}` };
+    const data = await res.json();
+    return { alive: true, agent: data.agent, uptime: data.uptime };
+  } catch (err) {
+    return { alive: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function* sendMessage(url, message) {
+  try {
+    const res = await fetch(`${url}/webhook`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ message, stream: true }),
+      signal: AbortSignal.timeout(12e4)
+    });
+    if (!res.ok || !res.body) {
+      yield `[ZeroClaw error: HTTP ${res.status}]`;
+      return;
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          try {
+            const payload = JSON.parse(line.slice(6));
+            if (payload.error) {
+              yield `[Error: ${payload.error}]`;
+              return;
+            }
+            if (payload.chunk) yield payload.chunk;
+            if (payload.done) return;
+          } catch {
+          }
+        }
+      }
+    } else {
+      const data = await res.json();
+      if (data.error) {
+        yield `[Error: ${data.error}]`;
+        return;
+      }
+      if (data.result) yield data.result;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("ECONNREFUSED")) {
+      yield `
+[Agent offline \u2014 run: neurogent start]
+`;
+    } else {
+      yield `
+[ZeroClaw error: ${msg}]
+`;
+    }
+  }
+}
+
+// src/shell/agents/executor.ts
+import { execSync } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { streamText } from "ai";
+function detectGlobalProvider() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { provider: "anthropic", name: "claude-3-5-sonnet-20241022" };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return { provider: "openai", name: "gpt-4o" };
+  }
+  return { provider: "ollama", name: "llama3.2" };
+}
+function buildModel(modelConfig) {
+  if (modelConfig.provider === "anthropic") {
+    const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY ?? "" });
+    return anthropic(modelConfig.name);
+  }
+  if (modelConfig.provider === "ollama") {
+    const ollama = createOpenAI({
+      apiKey: "ollama",
+      baseURL: modelConfig.baseUrl ?? process.env.OLLAMA_BASE_URL ?? "http://localhost:11434/v1"
+    });
+    return ollama(modelConfig.name);
+  }
+  const openaiClient = createOpenAI({ apiKey: process.env.OPENAI_API_KEY ?? "" });
+  return openaiClient(modelConfig.name);
+}
+function getEffectiveModel(agent, globalModel) {
+  return agent.model ?? globalModel ?? detectGlobalProvider();
+}
+function getGitContext() {
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const diff = execSync("git diff --stat HEAD 2>/dev/null || git diff --stat", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const log = execSync("git log --oneline -3", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (!branch || branch === "HEAD") return "";
+    let ctx = `
+
+[Git context \u2014 Branch: ${branch}`;
+    if (log) ctx += ` | Recent: ${log.split("\n")[0]}`;
+    if (diff) ctx += `]
+Changed files:
+${diff}`;
+    else ctx += "]";
+    return ctx;
+  } catch {
+    return "";
+  }
+}
+function resolveFileContext(message) {
+  return message.replace(/@file:([^\s]+)/g, (match, filePath) => {
+    try {
+      const resolved = path2.resolve(process.cwd(), filePath);
+      const content = fs2.readFileSync(resolved, "utf-8");
+      const ext = path2.extname(filePath).slice(1) || "text";
+      const lines = content.split("\n").length;
+      return `
+
+[File: ${filePath} (${lines} lines)]
+\`\`\`${ext}
+${content}
+\`\`\``;
+    } catch {
+      return `[File not found: ${filePath}]`;
+    }
+  });
+}
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = {
+    "claude-3-5-sonnet": { input: 3, output: 15 },
+    "claude-3-5-haiku": { input: 0.8, output: 4 },
+    "claude-3-opus": { input: 15, output: 75 },
+    "claude-3-haiku": { input: 0.25, output: 1.25 },
+    "gpt-4o": { input: 2.5, output: 10 },
+    "gpt-4o-mini": { input: 0.15, output: 0.6 },
+    "gpt-4-turbo": { input: 10, output: 30 }
+  };
+  const key = Object.keys(pricing).find((k) => model.name.includes(k));
+  if (!key) return 0;
+  const p = pricing[key];
+  return inputTokens / 1e6 * p.input + outputTokens / 1e6 * p.output;
+}
+async function* executeAgent(agent, userMessage, history, globalModel, onUsage) {
+  const zeroClawUrl = agent.zeroClawUrl ?? getAgentUrl(agent.id) ?? getAgentUrl("*");
+  if (zeroClawUrl) {
+    yield* sendMessage(zeroClawUrl, userMessage);
+    return;
+  }
+  const modelConfig = getEffectiveModel(agent, globalModel);
+  const messageWithFiles = resolveFileContext(userMessage);
+  const cleanMessage = messageWithFiles.replace(/@(?!file:)\S+/g, "").trim();
+  const messages = [
+    ...history.slice(-10).map((h) => ({ role: h.role, content: h.content })),
+    { role: "user", content: cleanMessage }
+  ];
+  let model;
+  try {
+    model = buildModel(modelConfig);
+  } catch (err) {
+    yield `[Provider init error: ${err instanceof Error ? err.message : String(err)}]`;
+    return;
+  }
+  try {
+    const result = await streamText({
+      model,
+      system: `${agent.systemPrompt}
+
+You are in a terminal chat. Be concise (under 250 words unless asked for more). Markdown renders here.${getGitContext()}`,
+      messages,
+      maxTokens: modelConfig.maxTokens ?? 1024,
+      temperature: modelConfig.temperature ?? 0.7
+    });
+    for await (const chunk of result.textStream) {
+      yield chunk;
+    }
+    try {
+      const usage = await result.usage;
+      if (usage && onUsage) {
+        const cost = calculateCost(modelConfig, usage.promptTokens, usage.completionTokens);
+        onUsage(cost);
+      }
+    } catch {
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("401") || msg.toLowerCase().includes("api key")) {
+      yield `
+\u26A0 API key missing or invalid. Set ANTHROPIC_API_KEY or OPENAI_API_KEY.
+`;
+    } else if (msg.includes("ECONNREFUSED") || msg.includes("fetch failed")) {
+      yield `
+\u26A0 Cannot reach ${modelConfig.provider}. Check your connection or Ollama setup.
+`;
+    } else {
+      yield `
+\u26A0 ${agent.name} error: ${msg}
+`;
+    }
+  }
+}
+
+export {
+  loadRuntime,
+  saveRuntime,
+  clearRuntime,
+  getAgentUrl,
+  pingAgent,
+  sendMessage,
+  getEffectiveModel,
+  executeAgent
+};

package/dist/chunk-ZTZVL6N5.js

@@ -0,0 +1,108 @@
+// src/security/policy.ts
+import { z } from "zod";
+import { parse as parseYaml } from "yaml";
+var praesidiaPolicySchema = z.object({
+  schema_version: z.union([z.number(), z.string()]),
+  enforcement: z.enum(["strict", "permissive"]).default("strict"),
+  rules: z.object({
+    ingress: z.array(z.object({
+      rule: z.string(),
+      action: z.enum(["reject", "allow", "log"])
+    })).optional().default([]),
+    egress: z.array(z.object({
+      rule: z.string(),
+      types: z.array(z.string()).optional(),
+      action: z.enum(["modify", "reject", "allow"])
+    })).optional().default([]),
+    tools: z.array(z.object({
+      match: z.string(),
+      action: z.enum(["allow", "reject"]),
+      require_human_approval: z.boolean().optional()
+    })).optional().default([])
+  })
+});
+function parsePolicy(yamlContent) {
+  const raw = parseYaml(yamlContent);
+  return praesidiaPolicySchema.parse(raw);
+}
+
+// src/security/hooks.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+var PraesidiaHooks = class _PraesidiaHooks {
+  policy = null;
+  isPermissive = false;
+  constructor(policy) {
+    if (policy) {
+      this.policy = policy;
+      this.isPermissive = policy.enforcement === "permissive";
+    }
+  }
+  static withPolicy(filePath) {
+    if (!fs.existsSync(filePath)) {
+      console.warn(`[Praesidia] Policy file not found at ${filePath}. Running with empty policy.`);
+      return new _PraesidiaHooks();
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const policy = parsePolicy(content);
+    return new _PraesidiaHooks(policy);
+  }
+  getPolicyHash() {
+    if (!this.policy) return "";
+    return crypto.createHash("sha256").update(JSON.stringify(this.policy)).digest("hex");
+  }
+  async checkIngress(payload) {
+    if (!this.policy?.rules.ingress.length) return { allowed: true };
+    const jailbreakPatterns = [
+      "ignore all previous instructions",
+      "disregard your instructions",
+      "you are now",
+      "act as if",
+      "pretend you are"
+    ];
+    const lower = payload.toLowerCase();
+    const triggered = jailbreakPatterns.some((p) => lower.includes(p));
+    if (triggered) {
+      const rejectRule = this.policy.rules.ingress.find((r) => r.action === "reject");
+      if (rejectRule && !this.isPermissive) {
+        return { allowed: false, reason: `Blocked by rule: ${rejectRule.rule}` };
+      }
+    }
+    return { allowed: true };
+  }
+  async checkEgress(chunk) {
+    if (!this.policy?.rules.egress.length) return { allowed: true, modifiedPayload: chunk };
+    let modified = chunk;
+    for (const rule of this.policy.rules.egress) {
+      if (rule.rule === "redact_pii" && rule.action === "modify") {
+        modified = modified.replace(/\b\d{4}[- ]\d{4}[- ]\d{4}[- ]\d{4}\b/g, "[REDACTED-CC]");
+        modified = modified.replace(/\b\d{3}-\d{2}-\d{4}\b/g, "[REDACTED-SSN]");
+        if (rule.types?.includes("EMAIL")) {
+          modified = modified.replace(/[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/g, "[REDACTED-EMAIL]");
+        }
+      }
+    }
+    return { allowed: true, modifiedPayload: modified };
+  }
+  async checkTool(toolName) {
+    if (!this.policy?.rules.tools.length) return { allowed: true };
+    for (const rule of this.policy.rules.tools) {
+      const isMatch = rule.match.endsWith("*") ? toolName.startsWith(rule.match.slice(0, -1)) : toolName === rule.match;
+      if (isMatch) {
+        if (rule.action === "reject" && !this.isPermissive) {
+          return { allowed: false, reason: `Tool blocked by policy rule: ${rule.match}` };
+        }
+        if (rule.require_human_approval) {
+          return { allowed: false, reason: "HUMAN_APPROVAL_REQUIRED" };
+        }
+        return { allowed: true };
+      }
+    }
+    return { allowed: true };
+  }
+};
+
+export {
+  parsePolicy,
+  PraesidiaHooks
+};

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node