@ftarganski/omni-ai 0.1.0

package/dist/chunk-3RZELMF2.js

@@ -0,0 +1,214 @@
+// ../skills/src/backend/analyze-dynamo-schema.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { z } from "zod";
+var InputSchema = z.object({
+  path: z.string().describe("Path to the *.model.ts file containing the OneTable schema")
+});
+function extractSchemaName(source) {
+  const match = /export\s+const\s+(\w+Schema)\s*=/.exec(source);
+  return match?.[1] ?? "UnknownSchema";
+}
+function extractEntityType(source) {
+  const match = /export\s+type\s+(\w+)\s*=\s*Entity</.exec(source);
+  return match?.[1] ?? "UnknownEntity";
+}
+function extractFields(source) {
+  const fieldsKeyIdx = source.indexOf("fields:");
+  if (fieldsKeyIdx === -1) return [];
+  const braceOpen = source.indexOf("{", fieldsKeyIdx);
+  if (braceOpen === -1) return [];
+  let depth = 0;
+  let fieldsEnd = -1;
+  for (let i = braceOpen; i < source.length; i++) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        fieldsEnd = i;
+        break;
+      }
+    }
+  }
+  if (fieldsEnd === -1) return [];
+  const fieldsBlock = source.slice(braceOpen + 1, fieldsEnd);
+  const fields = [];
+  for (const m of fieldsBlock.matchAll(/(\w+)\s*:\s*\{([^}]*)\}/g)) {
+    const body = m[2];
+    const typeMatch = /type\s*:\s*['"]?(\w+)['"]?/.exec(body);
+    const requiredMatch = /required\s*:\s*(true|false)/.exec(body);
+    fields.push({
+      name: m[1],
+      type: typeMatch?.[1] ?? "unknown",
+      required: requiredMatch?.[1] === "true",
+      isEnum: /enum\s*:\s*\w+/.test(body)
+    });
+  }
+  return fields;
+}
+function extractEnums(source) {
+  const enums = [];
+  for (const m of source.matchAll(/export\s+(?:const\s+)?enum\s+(\w+)\s*\{([^}]*)\}/g)) {
+    const values = m[2].split(",").map((v) => v.trim().split("=")[0].trim()).filter(Boolean);
+    enums.push({ name: m[1], values });
+  }
+  return enums;
+}
+function extractTypenames(source) {
+  const matches = source.match(/Typenames\.\w+/g) ?? [];
+  return [...new Set(matches)];
+}
+var analyzeDynamoSchemaSkill = {
+  name: "analyze-dynamo-schema",
+  description: "Parse a OneTable *.model.ts file and extract the schema name, entity type, fields (with types and required flags), enums, and Typenames references. Use this before generating a service to understand the exact entity shape.",
+  async execute(input) {
+    const { path } = InputSchema.parse(input);
+    const source = await readFile(resolve(path), "utf-8");
+    return {
+      schemaName: extractSchemaName(source),
+      entityType: extractEntityType(source),
+      fields: extractFields(source),
+      enums: extractEnums(source),
+      typenames: extractTypenames(source)
+    };
+  }
+};
+
+// ../skills/src/backend/analyze-graphql-schema.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { z as z2 } from "zod";
+var InputSchema2 = z2.object({
+  path: z2.string().describe("Path to the *.schema.graphql file")
+});
+function extractOperations(source, section) {
+  const sectionRe = new RegExp(`extend\\s+type\\s+${section}\\s*\\{([^}]*)\\}`, "s");
+  const match = sectionRe.exec(source);
+  if (!match) return [];
+  const ops = [];
+  for (const m of match[1].matchAll(/(\w+)\s*(\([^)]*\))?\s*:\s*([^\n@#]+)((?:\s*@\w+[^\n]*)*)/g)) {
+    const directives = m[4].trim().split(/\s*@/).filter(Boolean).map((d) => `@${d.trim()}`);
+    ops.push({
+      name: m[1],
+      args: (m[2] ?? "").trim(),
+      returns: m[3].trim(),
+      directives
+    });
+  }
+  return ops;
+}
+function extractTypes(source) {
+  const types = [];
+  for (const m of source.matchAll(/(?:^|\n)\s*(?:extend\s+)?type\s+(\w+)\s*(?:implements[^{]*)?\{/g)) {
+    if (!["Query", "Mutation", "Subscription"].includes(m[1])) types.push(m[1]);
+  }
+  return [...new Set(types)];
+}
+function extractInputs(source) {
+  return [...source.matchAll(/input\s+(\w+)\s*\{/g)].map((m) => m[1]);
+}
+function extractEnums2(source) {
+  return [...source.matchAll(/(?:extend\s+)?enum\s+(\w+)\s*\{/g)].map((m) => m[1]);
+}
+var analyzeGraphqlSchemaSkill = {
+  name: "analyze-graphql-schema",
+  description: "Parse a GraphQL SDL file and extract types, queries, mutations, inputs and enums. Use this before generating a resolver to understand what operations already exist and what the correct return types are.",
+  async execute(input) {
+    const { path } = InputSchema2.parse(input);
+    const source = await readFile2(resolve2(path), "utf-8");
+    return {
+      types: extractTypes(source),
+      queries: extractOperations(source, "Query"),
+      mutations: extractOperations(source, "Mutation"),
+      inputs: extractInputs(source),
+      enums: extractEnums2(source)
+    };
+  }
+};
+
+// ../skills/src/backend/analyze-nestjs-module.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+import { z as z3 } from "zod";
+var InputSchema3 = z3.object({
+  path: z3.string().describe("Path to the *.module.ts file")
+});
+function extractArrayItems(source, key) {
+  const re = new RegExp(`${key}\\s*:\\s*\\[([^\\]]*?)\\]`, "s");
+  const match = re.exec(source);
+  if (!match) return [];
+  return match[1].split(",").map(
+    (s) => s.trim().replace(/\/\/.*$/m, "").trim()
+  ).filter(Boolean);
+}
+function extractModuleName(source) {
+  const match = /export\s+class\s+(\w+Module)/.exec(source);
+  return match?.[1] ?? "UnknownModule";
+}
+var analyzeNestjsModuleSkill = {
+  name: "analyze-nestjs-module",
+  description: "Parse a NestJS *.module.ts file and extract its imports, providers, exports and controllers. Use this to understand what a module exposes before adding new providers or resolving injection dependencies.",
+  async execute(input) {
+    const { path } = InputSchema3.parse(input);
+    const source = await readFile3(resolve3(path), "utf-8");
+    return {
+      moduleName: extractModuleName(source),
+      imports: extractArrayItems(source, "imports"),
+      providers: extractArrayItems(source, "providers"),
+      exports: extractArrayItems(source, "exports"),
+      controllers: extractArrayItems(source, "controllers")
+    };
+  }
+};
+
+// ../skills/src/backend/find-code-pattern.ts
+import { readdir, readFile as readFile4 } from "fs/promises";
+import { join } from "path";
+import { z as z4 } from "zod";
+var patternSuffixes = {
+  service: [".service.ts"],
+  resolver: [".resolver.ts"],
+  listener: [".listener.ts"],
+  model: [".model.ts"],
+  test: [".spec.ts"],
+  schema: [".schema.graphql"]
+};
+var InputSchema4 = z4.object({
+  patternType: z4.enum(["service", "resolver", "listener", "model", "test", "schema"]).describe("Type of NestJS pattern to find examples of"),
+  directory: z4.string().describe("Root directory to search in"),
+  maxExamples: z4.number().int().positive().default(3).describe("Maximum number of examples to return")
+});
+async function walkForPattern(dir, suffixes, results, max) {
+  if (results.length >= max) return;
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  for (const entry of entries) {
+    if (results.length >= max) break;
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkForPattern(fullPath, suffixes, results, max);
+    } else if (entry.isFile() && suffixes.some((s) => entry.name.endsWith(s))) {
+      const content = await readFile4(fullPath, "utf-8");
+      results.push({ file: fullPath, content });
+    }
+  }
+}
+var findCodePatternSkill = {
+  name: "find-code-pattern",
+  description: "Find real examples of NestJS patterns (service, resolver, listener, model, test, schema) from the codebase. Use this before generating new code to understand the exact conventions and patterns already in use.",
+  async execute(input) {
+    const { patternType, directory, maxExamples } = InputSchema4.parse(input);
+    const suffixes = patternSuffixes[patternType];
+    const results = [];
+    await walkForPattern(directory, suffixes, results, maxExamples);
+    return results;
+  }
+};
+
+export {
+  analyzeDynamoSchemaSkill,
+  analyzeGraphqlSchemaSkill,
+  analyzeNestjsModuleSkill,
+  findCodePatternSkill
+};

package/dist/chunk-5WELBZWN.js

@@ -0,0 +1,70 @@
+// ../skills/src/multimodal/analyze-image.ts
+import { readFile } from "fs/promises";
+import { extname } from "path";
+import { z } from "zod";
+var SUPPORTED_MIME = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+var InputSchema = z.object({
+  prompt: z.string().describe("Question or instruction for the vision model, e.g. 'Describe this screenshot'"),
+  imagePath: z.string().optional().describe("Absolute or relative path to an image file on disk"),
+  imageUrl: z.string().url().optional().describe("Public URL of an image to fetch and analyse"),
+  imageBase64: z.string().optional().describe("Base64-encoded image data (without data-URL prefix)"),
+  mimeType: z.enum(SUPPORTED_MIME).optional().describe("MIME type \u2014 required when using imageBase64, inferred from extension otherwise")
+}).refine((d) => d.imagePath ?? d.imageUrl ?? d.imageBase64, {
+  message: "Provide exactly one of: imagePath, imageUrl, or imageBase64"
+});
+var EXT_TO_MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+async function loadImage(input) {
+  if (input.imagePath) {
+    const ext = extname(input.imagePath).toLowerCase();
+    const mimeType2 = input.mimeType ?? EXT_TO_MIME[ext];
+    if (!mimeType2) throw new Error(`Unsupported image extension "${ext}". Use: ${Object.keys(EXT_TO_MIME).join(", ")}`);
+    const data = (await readFile(input.imagePath)).toString("base64");
+    return { data, mimeType: mimeType2 };
+  }
+  if (input.imageUrl) {
+    const res = await fetch(input.imageUrl);
+    if (!res.ok) throw new Error(`Failed to fetch image: ${res.status} ${res.statusText}`);
+    const contentType = res.headers.get("content-type") ?? "";
+    const mimeType2 = input.mimeType ?? SUPPORTED_MIME.find((m) => contentType.startsWith(m));
+    if (!mimeType2) throw new Error(`Unsupported content-type "${contentType}"`);
+    const buffer = await res.arrayBuffer();
+    return { data: Buffer.from(buffer).toString("base64"), mimeType: mimeType2 };
+  }
+  const mimeType = input.mimeType;
+  if (!mimeType) throw new Error("mimeType is required when supplying imageBase64");
+  return { data: input.imageBase64, mimeType };
+}
+var analyzeImageSkill = {
+  name: "analyze-image",
+  description: "Analyse an image (screenshot, diagram, mockup, photo) using the configured vision-capable LLM provider. Accepts a file path, public URL, or raw base64 data. Returns a natural-language description or answer to your prompt.",
+  async execute(input, ctx) {
+    const parsed = InputSchema.parse(input);
+    if (!ctx.provider.capabilities.vision) {
+      throw new Error(
+        `Provider "${ctx.provider.name}" does not support vision. Configure a vision-capable provider (e.g. Anthropic claude-3, OpenAI gpt-4o).`
+      );
+    }
+    const { data, mimeType } = await loadImage(parsed);
+    const imagePart = { type: "image", mimeType, data };
+    const response = await ctx.provider.complete({
+      messages: [
+        {
+          role: "user",
+          content: [imagePart, { type: "text", text: parsed.prompt }]
+        }
+      ],
+      temperature: 0.2
+    });
+    return { analysis: response.content };
+  }
+};
+
+export {
+  analyzeImageSkill
+};