@ai-me-chat/core 0.0.1

package/dist/index.js

@@ -0,0 +1,621 @@
+// src/tools/generate-tools.ts
+import { z } from "zod";
+var DEFAULT_WRITE_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
+function generateToolDefinitions(routes, confirmation) {
+  const confirmMethods = confirmation?.methods ?? DEFAULT_WRITE_METHODS;
+  const tools = [];
+  for (const route of routes) {
+    for (const method of route.methods) {
+      const toolName = buildToolName(method, route.path);
+      const description = `${method} ${route.path}`;
+      tools.push({
+        name: toolName,
+        description,
+        parameters: buildParametersSchema(method, route.pathParams),
+        requiresConfirmation: confirmMethods.includes(method),
+        httpMethod: method,
+        path: route.path
+      });
+    }
+  }
+  return tools;
+}
+function buildToolName(method, routePath) {
+  const pathPart = routePath.replace(/^\/api\//, "").replace(/:/g, "").replace(/\*/g, "").replace(/\//g, "_").replace(/_+/g, "_").replace(/_$/, "");
+  return `${method.toLowerCase()}_${pathPart}`;
+}
+function generateToolDefinitionsWithSchemas(routes, schemas, confirmation) {
+  const confirmMethods = confirmation?.methods ?? DEFAULT_WRITE_METHODS;
+  const tools = [];
+  for (const route of routes) {
+    const fileSchemas = schemas.get(route.filePath) ?? [];
+    for (const method of route.methods) {
+      const toolName = buildToolName(method, route.path);
+      const description = `${method} ${route.path}`;
+      const matchingSchema = pickBestSchema(fileSchemas, method);
+      tools.push({
+        name: toolName,
+        description,
+        parameters: matchingSchema ? buildParametersSchemaFromExtracted(method, route.pathParams, matchingSchema) : buildParametersSchema(method, route.pathParams),
+        requiresConfirmation: confirmMethods.includes(method),
+        httpMethod: method,
+        path: route.path
+      });
+    }
+  }
+  return tools;
+}
+function pickBestSchema(fileSchemas, method) {
+  const exact = fileSchemas.find((s) => s.method === method);
+  if (exact) return exact;
+  if (method === "GET") {
+    return fileSchemas.find(
+      (s) => s.exportName.toLowerCase().includes("query") || s.exportName.toLowerCase().includes("search")
+    );
+  }
+  if (["POST", "PUT", "PATCH"].includes(method)) {
+    return fileSchemas.find(
+      (s) => s.exportName.toLowerCase().includes("body") || s.exportName.toLowerCase().includes("request")
+    );
+  }
+  return void 0;
+}
+function buildParametersSchemaFromExtracted(method, pathParams, extracted) {
+  const shape = {};
+  for (const param of pathParams) {
+    shape[param] = z.string().describe(`Path parameter: ${param}`);
+  }
+  const props = extracted.jsonSchema["properties"];
+  const requiredFields = new Set(
+    Array.isArray(extracted.jsonSchema["required"]) ? extracted.jsonSchema["required"] : []
+  );
+  if (props) {
+    const innerShape = {};
+    for (const [key, propSchema] of Object.entries(props)) {
+      const zodField = jsonSchemaScalarToZod(propSchema);
+      innerShape[key] = requiredFields.has(key) ? zodField : zodField.optional();
+    }
+    if (method === "GET") {
+      shape["query"] = z.object(innerShape).optional().describe("Query parameters");
+    } else if (["POST", "PUT", "PATCH"].includes(method)) {
+      shape["body"] = z.object(innerShape).optional().describe("Request body");
+    }
+  } else {
+    if (method === "GET") {
+      shape["query"] = z.object({}).passthrough().optional().describe("Query string parameters");
+    } else if (["POST", "PUT", "PATCH"].includes(method)) {
+      shape["body"] = z.object({}).passthrough().optional().describe("Request body (JSON object with any properties)");
+    }
+  }
+  return z.object(shape);
+}
+function jsonSchemaScalarToZod(schema) {
+  const anyOf = schema["anyOf"];
+  if (Array.isArray(anyOf)) {
+    const nonNull = anyOf.filter(
+      (s) => s["type"] !== "null"
+    );
+    if (nonNull.length === 1 && nonNull[0]) {
+      return jsonSchemaScalarToZod(nonNull[0]);
+    }
+    return z.unknown();
+  }
+  if (Array.isArray(schema["enum"])) {
+    const values = schema["enum"];
+    if (values.every((v) => typeof v === "string") && values.length >= 2) {
+      const [first, second, ...rest] = values;
+      return z.enum([first, second, ...rest]);
+    }
+  }
+  switch (schema["type"]) {
+    case "string":
+      return z.string();
+    case "number":
+    case "integer":
+      return z.number();
+    case "boolean":
+      return z.boolean();
+    case "array": {
+      const items = schema["items"];
+      return items ? z.array(jsonSchemaScalarToZod(items)) : z.array(z.unknown());
+    }
+    case "object":
+      return z.record(z.string(), z.unknown());
+    default:
+      return z.unknown();
+  }
+}
+function buildParametersSchema(method, pathParams) {
+  const shape = {};
+  for (const param of pathParams) {
+    shape[param] = z.string().describe(`Path parameter: ${param}`);
+  }
+  if (method === "GET") {
+    shape["query"] = z.record(z.string(), z.string()).optional().describe("Query string parameters");
+  } else if (["POST", "PUT", "PATCH"].includes(method)) {
+    shape["body"] = z.record(z.string(), z.unknown()).optional().describe("Request body");
+  }
+  return z.object(shape);
+}
+
+// src/tools/schema-extractor.ts
+function extractSchemasFromFile(_filePath, fileContent) {
+  const results = [];
+  const exportPattern = /export\s+const\s+(\w+)\s*=\s*z\.object\s*\(\s*\{([^]*?)\}\s*\)/g;
+  let match;
+  while ((match = exportPattern.exec(fileContent)) !== null) {
+    const exportName = match[1];
+    const objectBody = match[2];
+    if (!exportName) continue;
+    const jsonSchema = buildJsonSchema(objectBody);
+    const method = inferMethod(exportName);
+    results.push({ exportName, jsonSchema, method });
+  }
+  return results;
+}
+function inferMethod(exportName) {
+  const lower = exportName.toLowerCase();
+  if (lower.includes("body") || lower.includes("request")) return "POST";
+  if (lower.includes("query") || lower.includes("search")) return "GET";
+  return void 0;
+}
+function buildJsonSchema(objectBody) {
+  const properties = {};
+  const required = [];
+  const fields = splitFields(objectBody);
+  for (const field of fields) {
+    const fieldMatch = field.match(/^\s*(\w+)\s*:\s*(.+?)\s*$/s);
+    if (!fieldMatch) continue;
+    const fieldName = fieldMatch[1];
+    const typeExpr = fieldMatch[2];
+    if (!fieldName || !typeExpr) continue;
+    const { schema, isOptional } = parseZodType(typeExpr.trim());
+    properties[fieldName] = schema;
+    if (!isOptional) {
+      required.push(fieldName);
+    }
+  }
+  const jsonSchema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    jsonSchema["required"] = required;
+  }
+  return jsonSchema;
+}
+function splitFields(body) {
+  const fields = [];
+  let depth = 0;
+  let current = "";
+  for (const char of body) {
+    if (char === "(" || char === "[" || char === "{") {
+      depth++;
+      current += char;
+    } else if (char === ")" || char === "]" || char === "}") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      const trimmed2 = current.trim();
+      if (trimmed2) fields.push(trimmed2);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  const trimmed = current.trim();
+  if (trimmed) fields.push(trimmed);
+  return fields;
+}
+function parseZodType(expr) {
+  const { base, modifiers } = tokeniseExpr(expr);
+  let schema = resolveBaseType(base);
+  let isOptional = false;
+  for (const mod of modifiers) {
+    if (mod.startsWith(".optional")) {
+      isOptional = true;
+      schema = { anyOf: [schema, { type: "null" }] };
+    } else if (mod.startsWith(".nullable")) {
+      schema = { anyOf: [schema, { type: "null" }] };
+    } else if (mod.startsWith(".array")) {
+      schema = { type: "array", items: schema };
+    } else if (mod.startsWith(".default")) {
+      isOptional = true;
+    }
+  }
+  return { schema, isOptional };
+}
+function tokeniseExpr(expr) {
+  const modifiers = [];
+  let rest = expr.trim();
+  let depth = 0;
+  let baseEnd = 0;
+  let foundBase = false;
+  for (let i = 0; i < rest.length; i++) {
+    const ch = rest[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) {
+        baseEnd = i + 1;
+        foundBase = true;
+        break;
+      }
+    }
+  }
+  if (!foundBase) {
+    return { base: rest, modifiers: [] };
+  }
+  const base = rest.slice(0, baseEnd);
+  rest = rest.slice(baseEnd);
+  while (rest.startsWith(".")) {
+    depth = 0;
+    let modEnd = 0;
+    let foundMod = false;
+    for (let i = 1; i < rest.length; i++) {
+      const ch = rest[i];
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        depth--;
+        if (depth === 0) {
+          modEnd = i + 1;
+          foundMod = true;
+          break;
+        }
+      }
+    }
+    if (!foundMod) break;
+    modifiers.push(rest.slice(0, modEnd));
+    rest = rest.slice(modEnd);
+  }
+  return { base, modifiers };
+}
+function resolveBaseType(base) {
+  const trimmed = base.trim();
+  if (trimmed.startsWith("z.string")) return { type: "string" };
+  if (trimmed.startsWith("z.number")) return { type: "number" };
+  if (trimmed.startsWith("z.boolean")) return { type: "boolean" };
+  if (trimmed.startsWith("z.null")) return { type: "null" };
+  if (trimmed.startsWith("z.unknown") || trimmed.startsWith("z.any"))
+    return {};
+  if (trimmed.startsWith("z.enum")) {
+    const enumValues = extractEnumValues(trimmed);
+    return { type: "string", enum: enumValues };
+  }
+  if (trimmed.startsWith("z.array")) {
+    const inner = extractSingleArg(trimmed);
+    if (inner) {
+      const { schema: items } = parseZodType(inner);
+      return { type: "array", items };
+    }
+    return { type: "array" };
+  }
+  if (trimmed.startsWith("z.object")) {
+    return { type: "object" };
+  }
+  if (trimmed.startsWith("z.record")) return { type: "object" };
+  if (trimmed.startsWith("z.literal")) {
+    const val = extractLiteralValue(trimmed);
+    return val !== void 0 ? { const: val } : {};
+  }
+  return {};
+}
+function extractEnumValues(expr) {
+  const inner = extractSingleArg(expr);
+  if (!inner) return [];
+  const values = [];
+  const valuePattern = /["']([^"']+)["']/g;
+  let m;
+  while ((m = valuePattern.exec(inner)) !== null) {
+    if (m[1]) values.push(m[1]);
+  }
+  return values;
+}
+function extractSingleArg(expr) {
+  const openParen = expr.indexOf("(");
+  if (openParen === -1) return null;
+  let depth = 0;
+  for (let i = openParen; i < expr.length; i++) {
+    const ch = expr[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) {
+        return expr.slice(openParen + 1, i);
+      }
+    }
+  }
+  return null;
+}
+function extractLiteralValue(expr) {
+  const inner = extractSingleArg(expr)?.trim();
+  if (!inner) return void 0;
+  if (inner.startsWith('"') && inner.endsWith('"') || inner.startsWith("'") && inner.endsWith("'")) {
+    return inner.slice(1, -1);
+  }
+  if (inner === "true") return true;
+  if (inner === "false") return false;
+  const num = Number(inner);
+  if (!Number.isNaN(num)) return num;
+  return void 0;
+}
+
+// src/tools/openapi-parser.ts
+import { z as z2 } from "zod";
+var HTTP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options",
+  "trace"
+]);
+var DEFAULT_WRITE_METHODS2 = ["POST", "PUT", "PATCH", "DELETE"];
+function parseOpenAPISpec(spec) {
+  const routes = [];
+  for (const [rawPath, pathItem] of Object.entries(spec.paths ?? {})) {
+    const methods = [];
+    for (const key of Object.keys(pathItem)) {
+      if (HTTP_METHODS.has(key.toLowerCase())) {
+        methods.push(key.toUpperCase());
+      }
+    }
+    if (methods.length === 0) continue;
+    const expressPath = openApiPathToExpress(rawPath);
+    const pathParams = extractPathParams(rawPath);
+    routes.push({
+      path: expressPath,
+      methods,
+      pathParams,
+      // No real file path — use the spec path as a synthetic identifier.
+      filePath: `openapi:${rawPath}`
+    });
+  }
+  return routes;
+}
+function generateToolsFromOpenAPI(spec, confirmation) {
+  const confirmMethods = confirmation?.methods ?? DEFAULT_WRITE_METHODS2;
+  const tools = [];
+  for (const [rawPath, pathItem] of Object.entries(spec.paths ?? {})) {
+    for (const [methodKey, operation] of Object.entries(pathItem)) {
+      if (!HTTP_METHODS.has(methodKey.toLowerCase())) continue;
+      const method = methodKey.toUpperCase();
+      const op = operation;
+      const toolName = buildToolName2(method, rawPath, op.operationId);
+      const description = buildDescription(method, rawPath, op);
+      const expressPath = openApiPathToExpress(rawPath);
+      const parameters = buildZodSchema(method, rawPath, op, spec);
+      tools.push({
+        name: toolName,
+        description,
+        parameters,
+        requiresConfirmation: confirmMethods.includes(method),
+        httpMethod: method,
+        path: expressPath
+      });
+    }
+  }
+  return tools;
+}
+async function fetchOpenAPISpec(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch OpenAPI spec: ${response.status} ${response.statusText}`);
+  }
+  const spec = await response.json();
+  return spec;
+}
+function buildToolName2(method, rawPath, operationId) {
+  if (operationId) {
+    return operationId.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase().replace(/_+/g, "_").replace(/^_|_$/g, "");
+  }
+  const pathPart = rawPath.replace(/^\//, "").replace(/\{([^}]+)\}/g, "$1").replace(/\//g, "_").replace(/_+/g, "_").replace(/_$/, "");
+  return `${method.toLowerCase()}_${pathPart}`;
+}
+function buildDescription(method, rawPath, op) {
+  if (op.summary) return op.summary;
+  if (op.description) return op.description;
+  return `${method} ${rawPath}`;
+}
+function openApiPathToExpress(path) {
+  return path.replace(/\{([^}]+)\}/g, ":$1");
+}
+function extractPathParams(path) {
+  const params = [];
+  const re = /\{([^}]+)\}/g;
+  let m;
+  while ((m = re.exec(path)) !== null) {
+    if (m[1]) params.push(m[1]);
+  }
+  return params;
+}
+function buildZodSchema(method, rawPath, op, spec) {
+  const shape = {};
+  for (const paramName of extractPathParams(rawPath)) {
+    shape[paramName] = z2.string().describe(`Path parameter: ${paramName}`);
+  }
+  for (const param of op.parameters ?? []) {
+    if (param.in !== "path" && param.in !== "query") continue;
+    if (param.in === "path") {
+      if (param.description) {
+        shape[param.name] = z2.string().describe(param.description);
+      }
+      continue;
+    }
+    const resolved = resolveSchema(param.schema ?? {}, spec);
+    let zodField = jsonSchemaToZod(resolved);
+    if (param.description) zodField = zodField.describe(param.description);
+    shape[param.name] = param.required ? zodField : zodField.optional();
+  }
+  if (["POST", "PUT", "PATCH"].includes(method) && op.requestBody) {
+    const jsonContent = op.requestBody.content["application/json"] ?? Object.values(op.requestBody.content)[0];
+    if (jsonContent?.schema) {
+      const resolved = resolveSchema(jsonContent.schema, spec);
+      const bodySchema = jsonSchemaObjectToZod(resolved, spec);
+      shape["body"] = op.requestBody.required ? bodySchema : bodySchema.optional();
+    } else {
+      shape["body"] = z2.record(z2.string(), z2.unknown()).optional().describe("Request body");
+    }
+  }
+  return z2.object(shape);
+}
+function resolveSchema(schema, spec) {
+  const ref = schema["$ref"];
+  if (typeof ref !== "string") return schema;
+  const prefix = "#/components/schemas/";
+  if (!ref.startsWith(prefix)) return schema;
+  const schemaName = ref.slice(prefix.length);
+  const resolved = spec.components?.schemas?.[schemaName];
+  return resolved ?? schema;
+}
+function jsonSchemaObjectToZod(schema, spec) {
+  if (schema["type"] !== "object") {
+    return jsonSchemaToZod(schema);
+  }
+  const props = schema["properties"];
+  if (!props) {
+    return z2.record(z2.string(), z2.unknown()).describe("Request body");
+  }
+  const required = new Set(
+    Array.isArray(schema["required"]) ? schema["required"] : []
+  );
+  const shape = {};
+  for (const [propName, propSchema] of Object.entries(props)) {
+    const resolved = resolveSchema(propSchema, spec);
+    const zodField = jsonSchemaToZod(resolved);
+    shape[propName] = required.has(propName) ? zodField : zodField.optional();
+  }
+  return z2.object(shape);
+}
+function jsonSchemaToZod(schema) {
+  const type = schema["type"];
+  const anyOf = schema["anyOf"] ?? schema["oneOf"];
+  if (Array.isArray(anyOf) && anyOf.length >= 2) {
+    const members = anyOf.map(
+      (s) => jsonSchemaToZod(s)
+    );
+    const [first, second, ...rest] = members;
+    return z2.union([first, second, ...rest]);
+  }
+  if (schema["enum"] !== void 0) {
+    const values = schema["enum"];
+    if (values.every((v) => typeof v === "string")) {
+      const [first, second, ...rest] = values;
+      if (first !== void 0 && second !== void 0) {
+        return z2.enum([first, second, ...rest]);
+      }
+      if (first !== void 0) return z2.literal(first);
+    }
+    return z2.unknown();
+  }
+  switch (type) {
+    case "string":
+      return z2.string();
+    case "number":
+    case "integer":
+      return z2.number();
+    case "boolean":
+      return z2.boolean();
+    case "null":
+      return z2.null();
+    case "array": {
+      const items = schema["items"];
+      return items ? z2.array(jsonSchemaToZod(items)) : z2.array(z2.unknown());
+    }
+    case "object": {
+      const props = schema["properties"];
+      if (!props) return z2.record(z2.string(), z2.unknown());
+      const required = new Set(
+        Array.isArray(schema["required"]) ? schema["required"] : []
+      );
+      const innerShape = {};
+      for (const [k, v] of Object.entries(props)) {
+        const field = jsonSchemaToZod(v);
+        innerShape[k] = required.has(k) ? field : field.optional();
+      }
+      return z2.object(innerShape);
+    }
+    default:
+      return z2.unknown();
+  }
+}
+
+// src/executor.ts
+async function executeTool(tool, params, context) {
+  const id = crypto.randomUUID();
+  const startTime = /* @__PURE__ */ new Date();
+  try {
+    let response;
+    if (tool.execute) {
+      response = await tool.execute(params);
+    } else if (tool.httpMethod && tool.path) {
+      response = await executeHttpTool(tool, params, context);
+    } else {
+      throw new Error(`Tool "${tool.name}" has no execute function or HTTP path`);
+    }
+    return {
+      id,
+      toolName: tool.name,
+      parameters: params,
+      statusCode: 200,
+      response,
+      confirmed: !tool.requiresConfirmation,
+      executedAt: startTime
+    };
+  } catch (error) {
+    return {
+      id,
+      toolName: tool.name,
+      parameters: params,
+      statusCode: 500,
+      response: { error: error instanceof Error ? error.message : "Unknown error" },
+      confirmed: false,
+      executedAt: startTime
+    };
+  }
+}
+async function executeHttpTool(tool, params, context) {
+  const method = tool.httpMethod;
+  let url = `${context.baseUrl}${tool.path}`;
+  for (const [key, value] of Object.entries(params)) {
+    if (url.includes(`:${key}`)) {
+      url = url.replace(`:${key}`, encodeURIComponent(String(value)));
+    }
+  }
+  const fetchOptions = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...context.headers
+    }
+  };
+  if (method === "GET" && params.query) {
+    const queryParams = new URLSearchParams(
+      params.query
+    );
+    url += `?${queryParams.toString()}`;
+  } else if (["POST", "PUT", "PATCH"].includes(method) && params.body) {
+    fetchOptions.body = JSON.stringify(params.body);
+  }
+  const response = await fetch(url, fetchOptions);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+export {
+  executeTool,
+  extractSchemasFromFile,
+  fetchOpenAPISpec,
+  generateToolDefinitions,
+  generateToolDefinitionsWithSchemas,
+  generateToolsFromOpenAPI,
+  parseOpenAPISpec
+};
+//# sourceMappingURL=index.js.map