@kraken-ai/platform 0.0.1

package/dist/cli.js

@@ -0,0 +1,1297 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as z12 from "zod";
+
+// src/cli/codegen.ts
+import fs from "fs";
+import path from "path";
+
+// src/cli/log.ts
+var supportsColor = !("NO_COLOR" in process.env) && process.env.FORCE_COLOR !== "0" && (process.stderr.isTTY ?? false);
+var code = (open, close) => {
+  const openStr = `\x1B[${open}m`;
+  const closeStr = `\x1B[${close}m`;
+  return (s) => supportsColor ? `${openStr}${s}${closeStr}` : s;
+};
+var bold = code(1, 22);
+var dim = code(2, 22);
+var red = code(31, 39);
+var yellow = code(33, 39);
+var green = code(32, 39);
+var cyan = code(36, 39);
+var warn = (msg) => {
+  process.stderr.write(`  ${dim("[kraken-ai:")} ${yellow("warn")}${dim("]")} ${msg}
+`);
+};
+
+// src/cli/validate.ts
+var ENTITY_NAME_REGEX = /^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/;
+var isValidEntityName = (name) => name.length === 1 ? /^[a-z0-9]$/.test(name) : ENTITY_NAME_REGEX.test(name);
+var SKILL_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,62}[a-zA-Z0-9]$/;
+var isValidSkillName = (basename) => basename.length === 1 ? /^[a-zA-Z0-9]$/.test(basename) : SKILL_NAME_REGEX.test(basename);
+var isValidSkillId = (id) => {
+  const base = id.endsWith(".md") ? id.slice(0, -3) : id;
+  return isValidSkillName(base);
+};
+var TOOL_NAME_REGEX = /^[a-z][a-z0-9_-]{0,62}[a-z0-9]$/;
+var isValidToolName = (name) => name.length === 1 ? /^[a-z]$/.test(name) : TOOL_NAME_REGEX.test(name);
+var PROPERTY_NAME_REGEX = /^[a-zA-Z_$][a-zA-Z0-9_$]{0,254}$/;
+var FORBIDDEN_PROPS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+var isValidPropertyName = (name) => PROPERTY_NAME_REGEX.test(name) && !FORBIDDEN_PROPS.has(name);
+var MAX_SCHEMA_DEPTH = 20;
+var MAX_OBJECT_BREADTH = 200;
+var validateSchemaBundle = (bundle) => {
+  for (const agent of bundle.agents) {
+    assertValidEntity("agent id", agent.id);
+    validateJsonSchemaProperties("agent input schema", agent.input, 0);
+    validateJsonSchemaProperties("agent output schema", agent.output, 0);
+    if (agent.actions) {
+      for (const [actionName, actionSchema] of Object.entries(agent.actions)) {
+        assertValidEntity("agent action name", actionName);
+        validateJsonSchemaProperties("agent action schema", actionSchema, 0);
+      }
+    }
+  }
+  for (const query of bundle.queries) {
+    assertValidEntity("query name", query.name);
+    validateJsonSchemaProperties("query params schema", query.params, 0);
+    for (const col of query.columns) {
+      assertValidProperty("query column name", col.name);
+    }
+  }
+  for (const connector of bundle.connectors) {
+    assertValidEntity("connector id", connector.id);
+    for (const tool of connector.tools) {
+      assertValidTool("connector tool name", tool.name);
+      validateJsonSchemaProperties("connector tool parameters", tool.parameters, 0);
+    }
+  }
+  for (const pipeline of bundle.pipelines) {
+    assertValidEntity("pipeline name", pipeline.pipeline);
+    for (const query of pipeline.queries) {
+      assertValidEntity("pipeline query name", query.name);
+      validatePipelineSchema("pipeline query params", query.params, 0);
+      validatePipelineSchema("pipeline query returns", query.returns, 0);
+    }
+  }
+  for (const skill of bundle.skills) {
+    assertValidSkill("skill id", skill.id);
+  }
+};
+var assertValidEntity = (entityType, value) => {
+  if (!isValidEntityName(value)) {
+    throw new Error(
+      `Invalid remote schema: ${entityType} "${value}". Must match ${ENTITY_NAME_REGEX}`
+    );
+  }
+};
+var assertValidTool = (entityType, value) => {
+  if (!isValidToolName(value)) {
+    throw new Error(
+      `Invalid remote schema: ${entityType} "${value}". Must match ${TOOL_NAME_REGEX}`
+    );
+  }
+};
+var assertValidProperty = (entityType, value) => {
+  if (!isValidPropertyName(value)) {
+    throw new Error(
+      `Invalid remote schema: ${entityType} "${value}". Must match ${PROPERTY_NAME_REGEX} and not be a forbidden property`
+    );
+  }
+};
+var assertValidSkill = (entityType, value) => {
+  if (!isValidSkillId(value)) {
+    throw new Error(
+      `Invalid remote schema: ${entityType} "${value}". Must match ${SKILL_NAME_REGEX} (with optional .md extension)`
+    );
+  }
+};
+var validateJsonSchemaProperties = (context, schema, depth) => {
+  if (!schema || typeof schema !== "object") return;
+  if (depth > MAX_SCHEMA_DEPTH) {
+    throw new Error(
+      `Invalid remote schema: ${context} exceeds maximum nesting depth of ${MAX_SCHEMA_DEPTH}`
+    );
+  }
+  const props = schema.properties;
+  if (props) {
+    const keys = Object.keys(props);
+    if (keys.length > MAX_OBJECT_BREADTH) {
+      throw new Error(
+        `Invalid remote schema: ${context} has ${keys.length} properties, exceeding limit of ${MAX_OBJECT_BREADTH}`
+      );
+    }
+    for (const key of keys) {
+      assertValidProperty(`${context} property name`, key);
+      validateJsonSchemaProperties(context, props[key] ?? {}, depth + 1);
+    }
+  }
+  const items = schema.items;
+  if (items) {
+    validateJsonSchemaProperties(context, items, depth + 1);
+  }
+  for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+    const variants = schema[keyword];
+    if (variants) {
+      for (const variant of variants) {
+        validateJsonSchemaProperties(context, variant, depth + 1);
+      }
+    }
+  }
+};
+var validatePipelineSchema = (context, schema, depth) => {
+  if (!schema || typeof schema !== "object") return;
+  if (depth > MAX_SCHEMA_DEPTH) {
+    throw new Error(
+      `Invalid remote schema: ${context} exceeds maximum nesting depth of ${MAX_SCHEMA_DEPTH}`
+    );
+  }
+  if ("$ref" in schema) {
+    throw new Error(
+      `Invalid remote schema: ${context} contains "$ref" which is not supported in pipeline schemas`
+    );
+  }
+  if ("pattern" in schema) {
+    delete schema.pattern;
+  }
+  const props = schema.properties;
+  if (props) {
+    const keys = Object.keys(props);
+    if (keys.length > MAX_OBJECT_BREADTH) {
+      throw new Error(
+        `Invalid remote schema: ${context} has ${keys.length} properties, exceeding limit of ${MAX_OBJECT_BREADTH}`
+      );
+    }
+    for (const key of keys) {
+      assertValidProperty(`${context} property name`, key);
+      validatePipelineSchema(context, props[key] ?? {}, depth + 1);
+    }
+  }
+  const items = schema.items;
+  if (items) {
+    validatePipelineSchema(context, items, depth + 1);
+  }
+  for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+    const variants = schema[keyword];
+    if (variants) {
+      for (const variant of variants) {
+        validatePipelineSchema(context, variant, depth + 1);
+      }
+    }
+  }
+};
+
+// src/cli/codegen.ts
+var generateTypes = (schemas, projectRoot) => {
+  validateSchemaBundle(schemas);
+  const outDir = path.join(projectRoot, ".kraken-ai");
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+  const stalePipelinesTs = path.join(outDir, "pipelines.ts");
+  if (fs.existsSync(stalePipelinesTs)) {
+    fs.rmSync(stalePipelinesTs);
+    warn(
+      "Migrated: removed .kraken-ai/pipelines.ts. Pipeline schemas now in pipelines.json + pipelines.d.ts."
+    );
+  }
+  fs.writeFileSync(path.join(outDir, "agents.d.ts"), generateAgentsDts(schemas.agents));
+  fs.writeFileSync(path.join(outDir, "queries.d.ts"), generateQueriesDts(schemas.queries));
+  const connectorsDtsPath = path.join(outDir, "connectors.d.ts");
+  if (schemas.connectors.length > 0) {
+    fs.writeFileSync(connectorsDtsPath, generateConnectorsDts(schemas.connectors));
+  } else if (fs.existsSync(connectorsDtsPath)) {
+    fs.rmSync(connectorsDtsPath);
+  }
+  fs.writeFileSync(path.join(outDir, "pipelines.json"), generatePipelinesJson(schemas.pipelines));
+  fs.writeFileSync(path.join(outDir, "pipelines.d.ts"), generatePipelinesDts(schemas.pipelines));
+  const platformTypesDtsPath = path.join(outDir, "platform-types.d.ts");
+  const platformTypesDts = generatePlatformTypesDts(
+    schemas.agents,
+    schemas.connectors,
+    schemas.skills
+  );
+  if (platformTypesDts) {
+    fs.writeFileSync(platformTypesDtsPath, platformTypesDts);
+  } else if (fs.existsSync(platformTypesDtsPath)) {
+    fs.rmSync(platformTypesDtsPath);
+  }
+  fs.writeFileSync(
+    path.join(outDir, "index.d.ts"),
+    generateIndexDts(
+      schemas.connectors.length > 0,
+      schemas.pipelines.length > 0,
+      platformTypesDts != null
+    )
+  );
+  fs.writeFileSync(path.join(outDir, "manifest.json"), JSON.stringify(schemas, null, 2));
+};
+var generateAgentsDts = (agents) => {
+  const entries = agents.map((a) => {
+    const input = jsonSchemaToTsType(a.input);
+    const output = jsonSchemaToTsType(a.output);
+    const actions = generateActionsType(a.actions);
+    return `  "${a.id}": {
+    input: ${input}
+    output: ${output}
+    actions: ${actions}
+  }`;
+  }).join("\n");
+  return `// Auto-generated by \`kraken generate\` \u2014 do not edit manually
+
+export interface AgentRegistry {
+${entries}
+}
+`;
+};
+var generateActionsType = (actions) => {
+  if (!actions || Object.keys(actions).length === 0) {
+    return "Record<string, never>";
+  }
+  const entries = Object.entries(actions).map(([name, schema]) => `"${name}": ${jsonSchemaToTsType(schema)}`).join("; ");
+  return `{ ${entries} }`;
+};
+var generateQueriesDts = (queries) => {
+  const entries = queries.map((q) => {
+    const params = jsonSchemaToTsType(q.params);
+    const row = columnsToTsType(q.columns);
+    return `  "${q.name}": {
+    params: ${params}
+    row: ${row}
+  }`;
+  }).join("\n");
+  return `// Auto-generated by \`kraken generate\` \u2014 do not edit manually
+
+export interface QueryRegistry {
+${entries}
+}
+`;
+};
+var generateConnectorsDts = (connectors) => {
+  const ids = connectors.map((c) => `"${c.id}"`).join(" | ");
+  const entries = connectors.map((c) => {
+    const tools = c.tools.map((t) => {
+      const params = jsonSchemaToTsType(t.parameters);
+      return `    "${t.name}": ${params}`;
+    }).join("\n");
+    return `  "${c.id}": {
+${tools}
+  }`;
+  }).join("\n");
+  return `// Auto-generated by \`kraken generate\` \u2014 do not edit manually
+
+export type ConnectorId = ${ids};
+
+export interface ConnectorTools {
+${entries}
+}
+`;
+};
+var generateIndexDts = (hasConnectors, hasPipelines, hasPlatformTypes) => {
+  let content = `// Auto-generated by \`kraken generate\` \u2014 do not edit manually
+
+export type { AgentRegistry } from "./agents"
+export type { QueryRegistry } from "./queries"
+`;
+  if (hasConnectors) {
+    content += `export type { ConnectorId, ConnectorTools } from "./connectors"
+`;
+  }
+  if (hasPipelines) {
+    content += `/// <reference path="./pipelines.d.ts" />
+`;
+  }
+  if (hasPlatformTypes) {
+    content += `/// <reference path="./platform-types.d.ts" />
+`;
+  }
+  return content;
+};
+var generatePlatformTypesDts = (agents, connectors, skills) => {
+  const entries = [];
+  if (agents.length > 0) {
+    const ids = agents.map((a) => `"${a.id}"`).join(" | ");
+    entries.push(`    agentId: ${ids};`);
+  }
+  if (connectors.length > 0) {
+    const ids = connectors.map((c) => `"${c.id}"`).join(" | ");
+    entries.push(`    connectorId: ${ids};`);
+  }
+  if (skills.length > 0) {
+    const ids = skills.map((s) => `"${s.id}"`).join(" | ");
+    entries.push(`    skillId: ${ids};`);
+  }
+  if (entries.length === 0) return null;
+  return [
+    `// Auto-generated by \`kraken generate\` \u2014 do not edit manually`,
+    `export {};`,
+    ``,
+    `declare module "@kraken-ai/platform" {`,
+    `  interface KrakenTypeRegistry {`,
+    ...entries,
+    `  }`,
+    `}`,
+    ``
+  ].join("\n");
+};
+var MAX_TS_TYPE_DEPTH = 20;
+var jsonSchemaToTsType = (schema, depth = 0) => {
+  if (depth > MAX_TS_TYPE_DEPTH) return "unknown";
+  if (!schema || Object.keys(schema).length === 0) return "unknown";
+  const anyOf = schema.anyOf;
+  if (anyOf) {
+    const nonNull = anyOf.filter((s) => s.type !== "null");
+    const hasNull = anyOf.some((s) => s.type === "null");
+    if (nonNull.length === 1 && nonNull[0] && hasNull) {
+      return `${jsonSchemaToTsType(nonNull[0], depth + 1)} | null`;
+    }
+    if (nonNull.length > 1) {
+      const variants = nonNull.map((s) => jsonSchemaToTsType(s, depth + 1)).join(" | ");
+      return hasNull ? `${variants} | null` : variants;
+    }
+    if (nonNull.length === 0 && hasNull) {
+      return "null";
+    }
+  }
+  const type = schema.type;
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "object": {
+      const props = schema.properties;
+      if (!props) return "Record<string, unknown>";
+      const required = new Set(schema.required ?? []);
+      const fields = Object.entries(props).map(([k, val]) => {
+        const optional = !required.has(k);
+        const tsType = jsonSchemaToTsType(val, depth + 1);
+        return `${k}${optional ? "?" : ""}: ${tsType}`;
+      }).join("; ");
+      return `{ ${fields} }`;
+    }
+    case "array": {
+      const items = schema.items;
+      return `${jsonSchemaToTsType(items ?? {}, depth + 1)}[]`;
+    }
+    default:
+      return "unknown";
+  }
+};
+var columnsToTsType = (columns) => {
+  if (columns.length === 0) return "Record<string, unknown>";
+  const fields = columns.map((c) => `${c.name}: ${columnTypeToTs(c.type)}`).join("; ");
+  return `{ ${fields} }`;
+};
+var columnTypeToTs = (type) => {
+  switch (type.toLowerCase()) {
+    case "string":
+    case "text":
+    case "varchar":
+      return "string";
+    case "number":
+    case "integer":
+    case "float":
+    case "double":
+    case "decimal":
+      return "number";
+    case "boolean":
+    case "bool":
+      return "boolean";
+    default:
+      return "unknown";
+  }
+};
+var generatePipelinesJson = (pipelines) => {
+  if (pipelines.length === 0) return JSON.stringify({}, null, 2);
+  const result = {};
+  for (const p of pipelines) {
+    const queries = {};
+    for (const q of p.queries) {
+      queries[q.name] = { params: q.params, returns: q.returns };
+    }
+    result[p.pipeline] = queries;
+  }
+  return JSON.stringify(result, null, 2);
+};
+var generatePipelinesDts = (pipelines) => {
+  if (pipelines.length === 0) {
+    return [
+      `// Auto-generated by \`kraken generate\` \u2014 do not edit manually`,
+      `export {};`,
+      ``,
+      `declare module "@kraken-ai/platform" {`,
+      `  interface PipelineRegistry {}`,
+      `}`,
+      ``
+    ].join("\n");
+  }
+  const entries = pipelines.map((p) => {
+    const queryEntries = p.queries.map((q) => {
+      const params = jsonSchemaToTsType(q.params);
+      const returns = jsonSchemaToTsType(q.returns);
+      return `      "${q.name}": {
+        params: ${params}
+        returns: ${returns}
+      }`;
+    }).join("\n");
+    return `    "${p.pipeline}": {
+${queryEntries}
+    }`;
+  }).join("\n");
+  return [
+    `// Auto-generated by \`kraken generate\` \u2014 do not edit manually`,
+    `export {};`,
+    ``,
+    `declare module "@kraken-ai/platform" {`,
+    `  interface PipelineRegistry {`,
+    entries,
+    `  }`,
+    `}`,
+    ``
+  ].join("\n");
+};
+
+// src/cli/credentials.ts
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+var credentialsDir = () => path2.join(os.homedir(), ".kraken-ai");
+var credentialsPath = () => path2.join(credentialsDir(), "credentials.json");
+var saveCredentials = (creds) => {
+  const dir = credentialsDir();
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const filePath = credentialsPath();
+  fs2.writeFileSync(filePath, JSON.stringify(creds, null, 2), { mode: 384 });
+};
+var loadCredentials = () => {
+  const filePath = credentialsPath();
+  let creds = null;
+  if (fs2.existsSync(filePath)) {
+    try {
+      creds = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  const envKey = process.env.KRAKEN_API_KEY;
+  const envUrl = process.env.KRAKEN_BASE_URL;
+  if (envKey || envUrl) {
+    return {
+      apiKey: envKey ?? creds?.apiKey ?? "",
+      baseUrl: envUrl ?? creds?.baseUrl ?? ""
+    };
+  }
+  return creds;
+};
+var clearCredentials = () => {
+  const filePath = credentialsPath();
+  if (fs2.existsSync(filePath)) {
+    fs2.unlinkSync(filePath);
+  }
+};
+
+// src/cli/discover.ts
+import fs3 from "fs";
+import path3 from "path";
+import { pathToFileURL } from "url";
+import * as z10 from "zod";
+
+// src/agents/types/action.ts
+import * as z from "zod";
+var actionVariantConfigSchema = z.object({
+  schema: z.record(z.string(), z.unknown()),
+  webhook: z.string().url().optional(),
+  hasHandler: z.boolean()
+});
+var actionsConfigSchema = z.object({
+  variants: z.record(z.string(), actionVariantConfigSchema)
+}).strict();
+
+// src/agents/types/environment.ts
+import * as z2 from "zod";
+var environmentSchema = z2.enum(["dev", "staging", "prod"]);
+
+// src/agents/types/identity.ts
+import * as z3 from "zod";
+var jitPolicySchema = z3.enum(["auto-approve", "policy-based", "require-approval"]);
+var identityConfigSchema = z3.object({
+  basePermissions: z3.array(z3.string()),
+  requestablePermissions: z3.array(z3.string()).optional(),
+  jitPolicy: jitPolicySchema.optional(),
+  maxJitDurationMinutes: z3.number().int().positive().optional()
+});
+
+// src/agents/types/notifications.ts
+import * as z4 from "zod";
+var notificationConfigSchema = z4.object({
+  slack: z4.string().optional(),
+  onSuccess: z4.boolean().optional(),
+  onFailure: z4.boolean().optional(),
+  onTimeout: z4.boolean().optional()
+});
+
+// src/agents/types/platform-agent.ts
+import * as z8 from "zod";
+
+// src/agents/types/resources.ts
+import * as z5 from "zod";
+var resourceLimitsSchema = z5.object({
+  maxTokens: z5.number().int().positive().optional(),
+  maxCostUsd: z5.number().positive().optional(),
+  timeoutSeconds: z5.number().int().positive().optional()
+});
+var retryPolicySchema = z5.object({
+  maxAttempts: z5.number().int().min(1).optional(),
+  backoffSeconds: z5.number().positive().optional()
+});
+var concurrencyPolicySchema = z5.object({
+  maxParallelRuns: z5.number().int().min(1).optional()
+});
+
+// src/agents/types/team.ts
+import * as z6 from "zod";
+var teamConfigSchema = z6.object({
+  members: z6.array(z6.string()).min(1),
+  maxConcurrentWorkers: z6.number().int().min(1).optional(),
+  maxTokenBudgetPerWorker: z6.number().int().positive().optional(),
+  maxDurationPerWorker: z6.number().positive().optional()
+});
+
+// src/agents/types/trigger.ts
+import * as z7 from "zod";
+var cronTriggerSchema = z7.object({
+  type: z7.literal("cron"),
+  expression: z7.string(),
+  timezone: z7.string().optional()
+});
+var webhookTriggerSchema = z7.object({
+  type: z7.literal("webhook"),
+  path: z7.string().startsWith("/"),
+  method: z7.enum(["POST", "GET"]).optional()
+});
+var eventTriggerSchema = z7.object({
+  type: z7.literal("event"),
+  source: z7.string(),
+  event: z7.string()
+});
+var apiTriggerSchema = z7.object({ type: z7.literal("api") });
+var manualTriggerSchema = z7.object({ type: z7.literal("manual") });
+var triggerConfigSchema = z7.discriminatedUnion("type", [
+  cronTriggerSchema,
+  webhookTriggerSchema,
+  eventTriggerSchema,
+  apiTriggerSchema,
+  manualTriggerSchema
+]);
+
+// src/agents/types/platform-agent.ts
+var thinkingLevelSchema = z8.enum(["low", "medium", "high"]);
+var logLevelSchema = z8.enum(["silent", "debug", "info", "warn", "error"]);
+var agentDefinitionSchema = z8.object({
+  name: z8.string().min(1),
+  model: z8.string().min(1),
+  instructions: z8.string().min(1),
+  description: z8.string().optional(),
+  skills: z8.array(z8.string()).optional(),
+  temperature: z8.number().min(0).max(2).optional(),
+  allowTemperatureOverride: z8.boolean().optional(),
+  maxOutputTokens: z8.number().int().positive().optional(),
+  thinkingLevel: thinkingLevelSchema.optional(),
+  logLevel: logLevelSchema.optional()
+}).strict();
+var platformAgentConfigSchema = z8.object({
+  agent: agentDefinitionSchema,
+  connectors: z8.array(z8.string()).optional(),
+  trigger: triggerConfigSchema,
+  identity: identityConfigSchema.optional(),
+  resources: resourceLimitsSchema.optional(),
+  retries: retryPolicySchema.optional(),
+  concurrency: concurrencyPolicySchema.optional(),
+  team: teamConfigSchema.optional(),
+  notifications: notificationConfigSchema.optional(),
+  environment: environmentSchema.optional(),
+  actions: actionsConfigSchema.optional()
+}).strict();
+
+// src/agents/types/skill.ts
+import * as z9 from "zod";
+var platformSkillInputSchema = z9.object({
+  name: z9.string().min(1),
+  description: z9.string().optional()
+}).strict();
+
+// src/cli/discover.ts
+var MANIFEST_START = "---KRAKEN-MANIFEST-START---";
+var MANIFEST_END = "---KRAKEN-MANIFEST-END---";
+var skillEntrySchema = z10.object({
+  name: z10.string().min(1),
+  path: z10.string().min(1),
+  content: z10.string()
+});
+var connectorEntrySchema = z10.object({
+  name: z10.string().min(1),
+  path: z10.string().min(1)
+});
+var agentEntrySchema = z10.object({
+  name: z10.string().min(1),
+  entryPoint: z10.string().min(1),
+  config: platformAgentConfigSchema
+});
+var projectManifestSchema = z10.object({
+  agents: z10.array(agentEntrySchema),
+  skills: z10.array(skillEntrySchema),
+  connectors: z10.array(connectorEntrySchema)
+});
+var isPlatformAgentExport = (value) => value != null && typeof value === "object" && value.__type === "PlatformAgent" && "config" in value;
+var discoverAgents = async (projectRoot) => {
+  const agentsDir = path3.join(projectRoot, "agents");
+  if (!fs3.existsSync(agentsDir) || !fs3.statSync(agentsDir).isDirectory()) {
+    return [];
+  }
+  const files = fs3.readdirSync(agentsDir).filter((f) => f.endsWith(".js") || f.endsWith(".mjs")).sort();
+  const seen = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const filePath = path3.join(agentsDir, file);
+    try {
+      const mod = await import(pathToFileURL(filePath).href);
+      const exported = mod.default;
+      if (isPlatformAgentExport(exported) && !seen.has(exported.config.agent.name)) {
+        seen.set(exported.config.agent.name, {
+          config: exported.config,
+          entryPoint: `agents/${file}`
+        });
+      }
+    } catch (err) {
+      warn(`Skipping agents/${file}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return [...seen.values()];
+};
+var MAX_SKILL_SIZE = 100 * 1024;
+var discoverSkills = (projectRoot) => {
+  const skillsDir = path3.join(projectRoot, "skills");
+  if (!fs3.existsSync(skillsDir) || !fs3.statSync(skillsDir).isDirectory()) {
+    return [];
+  }
+  const files = fs3.readdirSync(skillsDir).sort();
+  const skills = [];
+  for (const file of files) {
+    if (!file.endsWith(".md")) {
+      warn(`Skipping skills/${file}: skill files must have a .md extension.`);
+      continue;
+    }
+    const basename = file.replace(/\.md$/, "");
+    if (!isValidSkillName(basename)) {
+      warn(
+        `Skipping skills/${file}: name must match [a-zA-Z0-9-] (letters, digits, hyphens only).`
+      );
+      continue;
+    }
+    const filePath = path3.join(skillsDir, file);
+    const stat = fs3.statSync(filePath);
+    if (stat.size > MAX_SKILL_SIZE) {
+      warn(`Skipping skills/${file}: exceeds ${MAX_SKILL_SIZE} byte limit.`);
+      continue;
+    }
+    const content = fs3.readFileSync(filePath, "utf-8");
+    skills.push({ name: file, path: `skills/${file}`, content });
+  }
+  return skills;
+};
+var discoverConnectors = (projectRoot) => {
+  const connectorsDir = path3.join(projectRoot, "connectors");
+  if (!fs3.existsSync(connectorsDir) || !fs3.statSync(connectorsDir).isDirectory()) {
+    return [];
+  }
+  const entries = fs3.readdirSync(connectorsDir, { withFileTypes: true });
+  const connectors = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    if (!isValidEntityName(name)) {
+      warn(
+        `Skipping connectors/${name}: name must match [a-z0-9-] (lowercase, digits, hyphens only).`
+      );
+      continue;
+    }
+    const connDir = path3.join(connectorsDir, name);
+    const hasPackageJson = fs3.existsSync(path3.join(connDir, "package.json"));
+    const hasDockerfile = fs3.existsSync(path3.join(connDir, "Dockerfile"));
+    if (!hasPackageJson && !hasDockerfile) {
+      continue;
+    }
+    connectors.push({ name, path: `connectors/${name}/` });
+  }
+  return connectors.sort((a, b) => a.name.localeCompare(b.name));
+};
+var discoverProject = async (projectRoot) => {
+  const discovered = await discoverAgents(projectRoot);
+  const agents = [];
+  for (const { config, entryPoint } of discovered) {
+    const name = config.agent.name;
+    if (!isValidEntityName(name)) {
+      throw new Error(`Invalid agent name: "${name}". Names must match ${ENTITY_NAME_REGEX}`);
+    }
+    agents.push({ name, entryPoint, config });
+  }
+  const skills = discoverSkills(projectRoot);
+  const connectors = discoverConnectors(projectRoot);
+  return { agents, skills, connectors };
+};
+var emitManifest = (manifest) => {
+  process.stdout.write(`${MANIFEST_START}
+`);
+  process.stdout.write(JSON.stringify(manifest));
+  process.stdout.write(`
+${MANIFEST_END}
+`);
+};
+
+// src/cli/pick.ts
+var pick = async (label, items) => {
+  if (items.length === 0) return null;
+  if (items.length === 1) return items[0] ?? null;
+  const { stdin, stdout } = process;
+  if (!stdin.isTTY) return null;
+  let cursor = 0;
+  const render = () => {
+    stdout.write(`  ${dim(label)}
+`);
+    for (let i = 0; i < items.length; i++) {
+      const marker = i === cursor ? cyan("\u276F") : " ";
+      const item = items[i] ?? "";
+      const text = i === cursor ? cyan(item) : dim(item);
+      stdout.write(`  ${marker} ${text}
+`);
+    }
+  };
+  const clear = () => {
+    const lines = items.length + 1;
+    for (let i = 0; i < lines; i++) {
+      stdout.write("\x1B[1A\x1B[2K");
+    }
+  };
+  stdin.setRawMode(true);
+  stdin.resume();
+  render();
+  return new Promise((resolve) => {
+    const onData = (data) => {
+      const key = data.toString();
+      if (key === "\x1B[A" || key === "k") {
+        clear();
+        cursor = (cursor - 1 + items.length) % items.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        clear();
+        cursor = (cursor + 1) % items.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        clear();
+        resolve(items[cursor] ?? null);
+      } else if (key === "" || key === "\x1B" || key === "q") {
+        cleanup();
+        clear();
+        resolve(null);
+      }
+    };
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+    };
+    stdin.on("data", onData);
+  });
+};
+
+// src/platform/types.ts
+import * as z11 from "zod";
+var jsonSchemaValue = z11.record(z11.string(), z11.unknown());
+var agentSchemaValidator = z11.object({
+  id: z11.string(),
+  name: z11.string(),
+  input: jsonSchemaValue,
+  output: jsonSchemaValue,
+  actions: z11.record(z11.string(), jsonSchemaValue).optional()
+}).passthrough();
+var queryColumnValidator = z11.object({
+  name: z11.string(),
+  type: z11.string(),
+  description: z11.string().optional()
+}).passthrough();
+var querySchemaValidator = z11.object({
+  name: z11.string(),
+  params: jsonSchemaValue,
+  columns: z11.array(queryColumnValidator)
+}).passthrough();
+var connectorToolValidator = z11.object({
+  name: z11.string(),
+  description: z11.string(),
+  parameters: jsonSchemaValue
+}).passthrough();
+var connectorSchemaValidator = z11.object({
+  id: z11.string(),
+  tools: z11.array(connectorToolValidator)
+}).passthrough();
+var skillSchemaValidator = z11.object({
+  id: z11.string(),
+  name: z11.string(),
+  description: z11.string().optional()
+}).passthrough();
+var pipelineQuerySchemaValidator = z11.object({
+  name: z11.string(),
+  description: z11.string(),
+  params: jsonSchemaValue,
+  returns: jsonSchemaValue
+}).passthrough();
+var pipelineSchemaValidator = z11.object({
+  pipeline: z11.string(),
+  queries: z11.array(pipelineQuerySchemaValidator)
+}).passthrough();
+
+// src/cli.ts
+var COMMANDS = /* @__PURE__ */ new Set(["login", "generate", "logout", "discover", "init", "dev"]);
+var parseArgs = (args) => {
+  const command = args[0];
+  if (!command || command === "--help" || !COMMANDS.has(command)) {
+    return { command: "help", positional: [], flags: {} };
+  }
+  const BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["check", "emit"]);
+  const positional = [];
+  const flags = {};
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg?.startsWith("--")) {
+      const name = arg.slice(2);
+      if (BOOLEAN_FLAGS.has(name)) {
+        flags[name] = "";
+      } else {
+        const next = args[++i];
+        if (next !== void 0) {
+          flags[name] = next;
+        }
+      }
+    } else if (arg) {
+      positional.push(arg);
+    }
+  }
+  return { command, positional, flags };
+};
+var runCommand = async (parsed, deps) => {
+  switch (parsed.command) {
+    case "login":
+      await handleLogin(parsed, deps);
+      return 0;
+    case "generate":
+      return handleGenerate(parsed, deps);
+    case "dev":
+      return handleDev(parsed, deps);
+    case "discover":
+      return handleDiscover(parsed, deps);
+    case "init":
+      return handleInit(parsed, deps);
+    case "logout":
+      handleLogout(deps);
+      return 0;
+    case "help":
+      printHelp(deps);
+      return 0;
+    default:
+      return 0;
+  }
+};
+var handleLogin = async (parsed, deps) => {
+  const url = parsed.flags.url ?? await deps.prompt("Platform URL: ");
+  const key = parsed.flags.key ?? await deps.prompt("API Key: ");
+  if (!url || !key) {
+    deps.log("Error: both URL and API key are required.");
+    return;
+  }
+  deps.saveCredentials({ baseUrl: url, apiKey: key });
+  deps.log(`Credentials saved. Connected to ${url}`);
+};
+var emptySchemaBundle = {
+  agents: [],
+  queries: [],
+  connectors: [],
+  pipelines: [],
+  skills: []
+};
+var fetchRemoteSchemas = async (creds, deps) => {
+  const headers = { Authorization: `Bearer ${creds.apiKey}` };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const endpoints = ["agents", "queries", "connectors", "pipelines", "skills"];
+    const responses = await Promise.all(
+      endpoints.map(
+        (ep) => deps.fetch(`${creds.baseUrl}/api/v1/schema/${ep}`, { headers, signal: controller.signal }).then(async (res) => {
+          if (!res.ok) return res;
+          const data = await res.json();
+          res._jsonData = data;
+          return res;
+        }).catch(() => null)
+      )
+    );
+    const [agentsRes, queriesRes, connectorsRes, pipelinesRes, skillsRes] = responses;
+    const allFailed = responses.every((r) => !r?.ok);
+    if (allFailed) {
+      warn(`Could not reach platform at ${creds.baseUrl}. Generating from local definitions only.`);
+      return emptySchemaBundle;
+    }
+    const agents = parseEndpointData(agentsRes, z12.array(agentSchemaValidator), "agents");
+    const queries = parseEndpointData(queriesRes, z12.array(querySchemaValidator), "queries");
+    const connectors = parseEndpointData(connectorsRes, z12.array(connectorSchemaValidator), "connectors");
+    const pipelines = parseEndpointData(pipelinesRes, z12.array(pipelineSchemaValidator), "pipelines");
+    const skills = parseEndpointData(skillsRes, z12.array(skillSchemaValidator), "skills");
+    return { agents, queries, connectors, pipelines, skills };
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+var parseEndpointData = (res, validator, endpointName) => {
+  if (!res?.ok) return [];
+  const data = res._jsonData;
+  const result = validator.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid remote schema from ${endpointName} endpoint: ${z12.prettifyError(result.error)}`
+    );
+  }
+  return result.data;
+};
+var mergeLocalAndRemote = (local, remote) => {
+  const remoteAgentIds = new Set(remote.agents.map((a) => a.id));
+  const remoteConnectorIds = new Set(remote.connectors.map((c) => c.id));
+  const remoteSkillIds = new Set(remote.skills.map((s) => s.id));
+  const localAgents = local.agents.filter((a) => !remoteAgentIds.has(a.name)).map((a) => ({ id: a.name, name: a.name, input: {}, output: {} }));
+  const localSkills = local.skills.filter((s) => !remoteSkillIds.has(s.name)).map((s) => ({ id: s.name, name: s.name }));
+  const localConnectors = local.connectors.filter((c) => !remoteConnectorIds.has(c.name)).map((c) => ({ id: c.name, tools: [] }));
+  return {
+    agents: [...remote.agents, ...localAgents],
+    queries: remote.queries,
+    connectors: [...remote.connectors, ...localConnectors],
+    pipelines: remote.pipelines,
+    skills: [...remote.skills, ...localSkills]
+  };
+};
+var handleGenerate = async (parsed, deps) => {
+  const outDir = parsed.flags.dir ?? process.cwd();
+  let manifest;
+  try {
+    manifest = await deps.discoverProject(outDir);
+  } catch (err) {
+    deps.log(`Error discovering project: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  const creds = deps.loadCredentials();
+  let remote;
+  if (creds?.apiKey && creds?.baseUrl) {
+    try {
+      remote = await fetchRemoteSchemas(creds, deps);
+    } catch (err) {
+      deps.log(`Error fetching remote schemas: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  } else {
+    warn(
+      "Not logged in. Generating from local definitions only. Run `kraken login` to sync with the platform."
+    );
+    remote = emptySchemaBundle;
+  }
+  const bundle = mergeLocalAndRemote(manifest, remote);
+  if ("check" in parsed.flags) {
+    const { mkdtempSync, readFileSync, rmSync } = await import("fs");
+    const { join } = await import("path");
+    const { tmpdir } = await import("os");
+    const tempDir = mkdtempSync(join(tmpdir(), "kraken-check-"));
+    try {
+      deps.generateTypes(bundle, tempDir);
+    } catch (err) {
+      rmSync(tempDir, { recursive: true, force: true });
+      deps.log(`Error generating types: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+    try {
+      const files = [
+        "pipelines.json",
+        "pipelines.d.ts",
+        "pipelines.ts",
+        // stale file detection — should not exist after migration
+        "agents.d.ts",
+        "queries.d.ts",
+        "connectors.d.ts",
+        "platform-types.d.ts",
+        "index.d.ts",
+        "manifest.json"
+      ];
+      let stale = false;
+      for (const file of files) {
+        const existingPath = join(outDir, ".kraken-ai", file);
+        const generatedPath = join(tempDir, ".kraken-ai", file);
+        const existing = safeReadFile(readFileSync, existingPath);
+        const generated = safeReadFile(readFileSync, generatedPath);
+        if (existing !== generated) {
+          deps.log(`Schema drift detected: .kraken-ai/${file}`);
+          stale = true;
+        }
+      }
+      if (stale) {
+        deps.log("Run `kraken generate` to update generated types.");
+        return 1;
+      }
+      deps.log("Schemas are up to date.");
+      return 0;
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+  try {
+    deps.generateTypes(bundle, outDir);
+  } catch (err) {
+    deps.log(`Error generating types: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  const localCount = manifest.agents.length + manifest.skills.length + manifest.connectors.length;
+  const remoteCount = remote.agents.length + remote.connectors.length + remote.skills.length;
+  deps.log(`Generated types for ${localCount} local + ${remoteCount} remote entities.`);
+  return 0;
+};
+var safeReadFile = (readFileSync, filePath) => {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var buildDevBootstrap = (fileUrl, file) => [
+  `void (async () => {`,
+  `  const mod = await import("${fileUrl}");`,
+  `  const a = mod.default;`,
+  `  if (!a || a.__type !== "PlatformAgent") {`,
+  `    console.error("Error: " + ${JSON.stringify(file)} + " must export a PlatformAgent as default.");`,
+  `    process.exit(1);`,
+  `  }`,
+  `  const { runDev } = await import("@kraken-ai/platform");`,
+  `  await runDev(a);`,
+  `})();`
+].join("\n");
+var discoverAgentFiles = async () => {
+  const { readdirSync, existsSync } = await import("fs");
+  const agentsDir = "agents";
+  if (!existsSync(agentsDir)) return [];
+  return readdirSync(agentsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mjs")).sort();
+};
+var handleDev = async (parsed, deps) => {
+  let name = parsed.positional[0];
+  if (!name) {
+    const agents = await discoverAgentFiles();
+    if (agents.length === 0) {
+      deps.log("No agent files found in agents/. Create one or pass a name: kraken dev <agent>");
+      return 1;
+    }
+    if (agents.length === 1) {
+      name = agents[0];
+    } else {
+      const selected = await pick("Select an agent:", agents);
+      if (!selected) return 0;
+      name = selected;
+    }
+  }
+  if (!name) return 1;
+  const file = name.includes("/") ? name : `agents/${name}`;
+  const { spawn } = await import("child_process");
+  const { resolve } = await import("path");
+  const { pathToFileURL: pathToFileURL2 } = await import("url");
+  const fileUrl = pathToFileURL2(resolve(file)).href;
+  const bootstrap = buildDevBootstrap(fileUrl, file);
+  const child = spawn("tsx", ["-e", bootstrap], {
+    stdio: "inherit",
+    cwd: process.cwd()
+  });
+  return new Promise((resolve2) => {
+    child.on("exit", (code2) => resolve2(code2 ?? 1));
+  });
+};
+var handleDiscover = async (parsed, deps) => {
+  const dir = parsed.flags.dir ?? process.cwd();
+  const manifest = await deps.discoverProject(dir);
+  const total = manifest.agents.length + manifest.skills.length + manifest.connectors.length;
+  if (total === 0) {
+    deps.log("No entities found in agents/, skills/, or connectors/ directories.");
+    return 1;
+  }
+  if ("emit" in parsed.flags) {
+    emitManifest(manifest);
+  } else {
+    deps.log(JSON.stringify(manifest, null, 2));
+  }
+  return 0;
+};
+var handleInit = async (parsed, deps) => {
+  const name = parsed.flags.name ?? await deps.prompt("Project name: ");
+  if (!name) {
+    deps.log("Error: project name is required.");
+    return 1;
+  }
+  const { writeFileSync, mkdirSync } = await import("fs");
+  const { join } = await import("path");
+  const root = join(process.cwd(), name);
+  mkdirSync(join(root, "agents"), { recursive: true });
+  mkdirSync(join(root, "skills"), { recursive: true });
+  mkdirSync(join(root, "connectors"), { recursive: true });
+  writeFileSync(
+    join(root, "package.json"),
+    JSON.stringify(
+      {
+        name,
+        private: true,
+        type: "module",
+        scripts: { build: "tsc" },
+        dependencies: {
+          "kraken-ai": "latest",
+          "@kraken-ai/platform": "latest"
+        },
+        devDependencies: {
+          typescript: "^5"
+        }
+      },
+      null,
+      2
+    )
+  );
+  writeFileSync(
+    join(root, "tsconfig.json"),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "NodeNext",
+          moduleResolution: "nodenext",
+          resolveJsonModule: true,
+          strict: true,
+          outDir: "dist",
+          rootDir: ".",
+          declaration: true,
+          esModuleInterop: true,
+          skipLibCheck: true
+        },
+        include: ["agents", "skills", "connectors"]
+      },
+      null,
+      2
+    )
+  );
+  writeFileSync(
+    join(root, "agents", "my-agent.ts"),
+    `import { definePlatformAgent } from "@kraken-ai/platform";
+
+export default definePlatformAgent({
+  agent: {
+    name: "my-agent",
+    model: "google/gemini-2.5-flash-preview-05-20",
+    instructions: "You are a helpful assistant.",
+  },
+  trigger: { type: "manual" },
+});
+`
+  );
+  writeFileSync(join(root, ".gitignore"), `node_modules/
+dist/
+.kraken-ai/
+data/
+.env
+`);
+  deps.log(`Created project at ${root}/`);
+  deps.log(`
+  cd ${name}
+  pnpm install
+  kraken login
+  kraken generate
+`);
+  return 0;
+};
+var handleLogout = (deps) => {
+  deps.clearCredentials();
+  deps.log("Credentials cleared.");
+};
+var printHelp = (deps) => {
+  deps.log(
+    `
+kraken \u2014 Kraken AI Platform CLI
+
+Commands:
+  dev        Run an agent locally with an interactive REPL
+             [agent]               Agent filename, e.g. researcher.ts (optional \u2014 picks from agents/ if omitted)
+
+  login      Store API credentials
+             --url <platform-url>  Platform instance URL
+             --key <api-key>       API key
+
+  generate   Discover local entities and fetch remote schemas to generate types
+             --dir <path>          Project root / output directory (default: cwd)
+             --check               Check if types are up-to-date (exit 1 if stale)
+
+  discover   Scan agents/, skills/, connectors/ and output project manifest
+             --dir <path>          Project root (default: cwd)
+             --emit                Output with sentinel markers (for orchestrator)
+
+  init       Create a new Kraken project
+             --name <project-name> Project name
+
+  logout     Clear stored credentials
+
+Environment variables:
+  KRAKEN_API_KEY    API key (overrides stored credentials)
+  KRAKEN_BASE_URL   Platform URL (overrides stored credentials)
+`.trim()
+  );
+};
+var readlinePrompt = async (question) => {
+  const { createInterface } = await import("readline");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+};
+var main = async () => {
+  const parsed = parseArgs(process.argv.slice(2));
+  const exitCode = await runCommand(parsed, {
+    clearCredentials,
+    loadCredentials,
+    saveCredentials,
+    generateTypes,
+    discoverProject,
+    fetch: globalThis.fetch,
+    prompt: readlinePrompt,
+    log: console.log
+  });
+  if (exitCode !== 0) process.exit(exitCode);
+};
+void main();
+export {
+  buildDevBootstrap,
+  parseArgs,
+  runCommand
+};
+//# sourceMappingURL=cli.js.map