@agent-native/core 0.85.6 → 0.86.0

package/corpus/templates/videos/actions/import-document.ts

@@ -1,125 +0,0 @@
-import { defineAction } from "@agent-native/core";
-import {
-  extractDocumentColors,
-  extractDocumentFonts,
-  classifyFile,
-  suggestionsForType,
-  unique,
-} from "@agent-native/core/server/design-token-utils";
-import { z } from "zod";
-
-export default defineAction({
-  description:
-    "Process uploaded document metadata (DOCX, PPTX, PDF, XLSX) and return " +
-    "structured design context. Since binary parsing happens client-side, this " +
-    "action accepts pre-extracted text and metadata, scans for design cues " +
-    "(colors, fonts, spacing), and returns structured hints the agent uses " +
-    "when building or refining a design system.",
-  schema: z.object({
-    files: z
-      .array(
-        z.object({
-          filename: z.string().describe("Original filename with extension"),
-          fileType: z
-            .string()
-            .describe(
-              "MIME type or extension (e.g. application/pdf, .docx, .pptx)",
-            ),
-          sizeBytes: z.number().describe("File size in bytes"),
-          textContent: z
-            .string()
-            .optional()
-            .describe(
-              "Text extracted client-side (PDF text layer, PPTX slide text, etc.)",
-            ),
-          metadata: z
-            .record(z.string(), z.any())
-            .optional()
-            .describe(
-              "Additional metadata from client parsing (detected fonts, theme colors, etc.)",
-            ),
-        }),
-      )
-      .describe("Array of uploaded file metadata"),
-  }),
-  readOnly: true,
-  run: async ({ files }) => {
-    const processedFiles = files.map((file) => {
-      const contentType = classifyFile(file.fileType);
-      const hasText = !!file.textContent && file.textContent.trim().length > 0;
-
-      let likelyColors: string[] = [];
-      let likelyFonts: string[] = [];
-
-      if (file.textContent) {
-        likelyColors = extractDocumentColors(file.textContent);
-        likelyFonts = extractDocumentFonts(file.textContent);
-      }
-
-      if (file.metadata) {
-        if (Array.isArray(file.metadata.colors)) {
-          likelyColors = unique([
-            ...likelyColors,
-            ...file.metadata.colors.map(String),
-          ]);
-        }
-        if (Array.isArray(file.metadata.fonts)) {
-          likelyFonts = unique([
-            ...likelyFonts,
-            ...file.metadata.fonts.map(String),
-          ]);
-        }
-      }
-
-      const suggestions = suggestionsForType(contentType, hasText);
-
-      return {
-        filename: file.filename,
-        fileType: file.fileType,
-        designHints: {
-          likelyColors,
-          likelyFonts,
-          contentType,
-          extractedText: file.textContent
-            ? file.textContent.slice(0, 2000)
-            : undefined,
-          suggestions,
-        },
-      };
-    });
-
-    const fileTypes = processedFiles.map((f) => f.designHints.contentType);
-    const hasPresentations = fileTypes.includes("presentation");
-    const hasDocuments = fileTypes.includes("document");
-    const hasSpreadsheets = fileTypes.includes("spreadsheet");
-
-    let agentInstructions =
-      "The user uploaded documents to inform the design system. ";
-
-    if (hasPresentations) {
-      agentInstructions +=
-        "Presentations (PPTX) are the strongest source for brand colors and heading fonts — " +
-        "prioritize any colors and fonts extracted from them. ";
-    }
-    if (hasDocuments) {
-      agentInstructions +=
-        "Documents (DOCX) reveal typography choices — body font, heading hierarchy, and text colors. ";
-    }
-    if (hasSpreadsheets) {
-      agentInstructions +=
-        "Spreadsheets (XLSX) may contain data visualization colors useful for chart palettes. ";
-    }
-
-    agentInstructions +=
-      "Use the extracted colors and fonts as starting points for the design system. " +
-      "If the extracted data is sparse, ask the user to send the file as a chat attachment " +
-      "so you can visually analyze its contents. Cross-reference with any existing design " +
-      "system or brand guidelines the user has set up.";
-
-    return {
-      source: "document",
-      files: processedFiles,
-      agentInstructions,
-    };
-  },
-});

package/corpus/templates/videos/actions/import-from-url.ts

@@ -1,18 +0,0 @@
-import { defineAction } from "@agent-native/core";
-import { extractDesignTokensFromUrl } from "@agent-native/core/server/design-token-utils";
-import { z } from "zod";
-
-export default defineAction({
-  description:
-    "Analyze a website URL to extract design tokens (colors, fonts, metadata) " +
-    "for use in creating or updating a design project. " +
-    "Returns extracted CSS variables, font faces, colors, and meta information.",
-  schema: z.object({
-    url: z.string().describe("Website URL to analyze"),
-  }),
-  readOnly: true,
-  http: { method: "GET" },
-  run: async ({ url }) => {
-    return extractDesignTokensFromUrl(url);
-  },
-});

package/corpus/templates/videos/actions/import-github.ts

@@ -1,182 +0,0 @@
-import { defineAction } from "@agent-native/core";
-import {
-  validateUrl,
-  parseOwnerRepo,
-  fetchGitHubJson,
-  fetchGitHubRaw,
-  parseTailwindConfig,
-  parseCss,
-  detectStylingFramework,
-  MAX_FILES,
-  MAX_FILE_SIZE,
-  ROOT_PATTERNS,
-  SECONDARY_PATHS,
-  COLOR_VAR_PATTERN,
-} from "@agent-native/core/server/design-token-utils";
-import { z } from "zod";
-
-export default defineAction({
-  description:
-    "Import design tokens from a public GitHub repository. " +
-    "Reads Tailwind configs, CSS files, theme/token files, and package.json " +
-    "to extract colors, fonts, spacing, and CSS custom properties.",
-  schema: z.object({
-    repoUrl: z
-      .string()
-      .describe(
-        'GitHub repository URL (e.g. "https://github.com/org/repo" or "org/repo")',
-      ),
-  }),
-  readOnly: true,
-  http: { method: "GET" },
-  run: async ({ repoUrl }) => {
-    const { owner, repo } = parseOwnerRepo(repoUrl.trim());
-
-    validateUrl(`https://api.github.com/repos/${owner}/${repo}`);
-
-    const rawFiles: Record<string, string> = {};
-    let fetchedCount = 0;
-
-    async function collectFile(path: string): Promise<void> {
-      if (fetchedCount >= MAX_FILES) return;
-      const content = await fetchGitHubRaw(owner, repo, path);
-      if (content) {
-        rawFiles[path] = content;
-        fetchedCount++;
-      }
-    }
-
-    // 1. List repository root
-    const rootListing = (await fetchGitHubJson(owner, repo, "")) as Array<{
-      name: string;
-      type: string;
-      size?: number;
-    }> | null;
-
-    if (!rootListing || !Array.isArray(rootListing)) {
-      throw new Error(
-        `Could not list repository contents for ${owner}/${repo}. ` +
-          "Ensure the repository is public and the URL is correct.",
-      );
-    }
-
-    // 2. Fetch root-level files matching patterns
-    const rootFilePromises: Promise<void>[] = [];
-    for (const entry of rootListing) {
-      if (entry.type !== "file") continue;
-      if (entry.size && entry.size > MAX_FILE_SIZE) continue;
-      const matches = ROOT_PATTERNS.some((p) => p.test(entry.name));
-      if (matches && fetchedCount < MAX_FILES) {
-        rootFilePromises.push(collectFile(entry.name));
-      }
-    }
-    await Promise.all(rootFilePromises);
-
-    // 3. Fetch secondary paths (files and directories)
-    const secondaryPromises: Promise<void>[] = [];
-    for (const path of SECONDARY_PATHS) {
-      if (fetchedCount >= MAX_FILES) break;
-
-      if (/\.\w+$/.test(path)) {
-        secondaryPromises.push(collectFile(path));
-      } else {
-        secondaryPromises.push(
-          (async () => {
-            const listing = (await fetchGitHubJson(
-              owner,
-              repo,
-              path,
-            )) as Array<{
-              name: string;
-              type: string;
-              path: string;
-              size?: number;
-            }> | null;
-            if (!listing || !Array.isArray(listing)) return;
-            const innerPromises: Promise<void>[] = [];
-            for (const entry of listing) {
-              if (fetchedCount >= MAX_FILES) break;
-              if (entry.type !== "file") continue;
-              if (entry.size && entry.size > MAX_FILE_SIZE) continue;
-              if (
-                /\.(css|scss|less)$/.test(entry.name) ||
-                /theme/i.test(entry.name) ||
-                /tokens?/i.test(entry.name)
-              ) {
-                innerPromises.push(collectFile(entry.path));
-              }
-            }
-            await Promise.all(innerPromises);
-          })(),
-        );
-      }
-    }
-    await Promise.all(secondaryPromises);
-
-    // 4. Parse collected files
-    let colors: Record<string, unknown> = {};
-    let fonts: string[] = [];
-    let spacing: Record<string, string> = {};
-    let borderRadius: Record<string, string> = {};
-    let cssCustomProperties: Record<string, string> = {};
-    let stylingFramework: string | undefined;
-
-    for (const [filename, content] of Object.entries(rawFiles)) {
-      if (/tailwind\.config\.\w+$/.test(filename)) {
-        const tw = parseTailwindConfig(content);
-        if (tw.colors)
-          colors = { ...colors, ...(tw.colors as Record<string, unknown>) };
-        if (tw.fontFamily) {
-          fonts.push(...Object.values(tw.fontFamily as Record<string, string>));
-        }
-        if (tw.spacing)
-          spacing = { ...spacing, ...(tw.spacing as Record<string, string>) };
-        if (tw.borderRadius) {
-          borderRadius = {
-            ...borderRadius,
-            ...(tw.borderRadius as Record<string, string>),
-          };
-        }
-      }
-
-      if (/\.(css|scss|less)$/.test(filename)) {
-        const parsed = parseCss(content);
-        if (parsed.cssCustomProperties) {
-          cssCustomProperties = {
-            ...cssCustomProperties,
-            ...parsed.cssCustomProperties,
-          };
-        }
-        if (parsed.fonts) fonts.push(...parsed.fonts);
-      }
-
-      if (filename === "package.json") {
-        stylingFramework = detectStylingFramework(content);
-      }
-    }
-
-    fonts = [...new Set(fonts)];
-
-    for (const [key, value] of Object.entries(cssCustomProperties)) {
-      if (COLOR_VAR_PATTERN.test(value.trim()) && !colors[key]) {
-        colors[key] = value.trim();
-      }
-    }
-
-    return {
-      source: "github" as const,
-      repoUrl: `https://github.com/${owner}/${repo}`,
-      colors: Object.keys(colors).length > 0 ? colors : undefined,
-      fonts: fonts.length > 0 ? fonts : undefined,
-      spacing: Object.keys(spacing).length > 0 ? spacing : undefined,
-      borderRadius:
-        Object.keys(borderRadius).length > 0 ? borderRadius : undefined,
-      cssCustomProperties:
-        Object.keys(cssCustomProperties).length > 0
-          ? cssCustomProperties
-          : undefined,
-      stylingFramework,
-      rawFiles,
-    };
-  },
-});

package/corpus/templates/videos/actions/list-compositions.ts

@@ -1,32 +0,0 @@
-import { defineAction } from "@agent-native/core";
-import { accessFilter } from "@agent-native/core/sharing";
-import { desc } from "drizzle-orm";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-
-export default defineAction({
-  description: "List all compositions ordered by most recently updated",
-  schema: z.object({}),
-  http: { method: "GET" },
-  run: async () => {
-    const db = getDb();
-    const rows = await db
-      .select()
-      .from(schema.compositions)
-      .where(accessFilter(schema.compositions, schema.compositionShares))
-      .orderBy(desc(schema.compositions.updatedAt));
-
-    return rows.map((row) => ({
-      id: row.id,
-      title: row.title,
-      type: row.type,
-      data: JSON.parse(row.data),
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-      ownerEmail: row.ownerEmail,
-      orgId: row.orgId,
-      visibility: row.visibility,
-    }));
-  },
-});

package/corpus/templates/videos/actions/list-design-systems.ts

@@ -1,66 +0,0 @@
-import { defineAction } from "@agent-native/core";
-import { accessFilter } from "@agent-native/core/sharing";
-import { desc } from "drizzle-orm";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-
-export default defineAction({
-  description:
-    "List all design systems accessible to the current user. " +
-    "Returns title, id, and whether each is the default.",
-  schema: z.object({
-    compact: z
-      .enum(["true", "false"])
-      .optional()
-      .describe("Set to 'true' for compact output (id, title, isDefault only)"),
-  }),
-  readOnly: true,
-  http: { method: "GET" },
-  run: async (args) => {
-    const db = getDb();
-    // Project only the columns the list needs. A bare `.select()` also pulls
-    // the heavy `assets` JSON blob and `custom_instructions`, which no list
-    // consumer reads — those are fetched on demand via `get-design-system`.
-    const rows = await db
-      .select({
-        id: schema.designSystems.id,
-        title: schema.designSystems.title,
-        description: schema.designSystems.description,
-        data: schema.designSystems.data,
-        isDefault: schema.designSystems.isDefault,
-        visibility: schema.designSystems.visibility,
-        createdAt: schema.designSystems.createdAt,
-        updatedAt: schema.designSystems.updatedAt,
-      })
-      .from(schema.designSystems)
-      .where(accessFilter(schema.designSystems, schema.designSystemShares))
-      .orderBy(desc(schema.designSystems.updatedAt));
-
-    if (rows.length === 0) {
-      return { count: 0, designSystems: [] };
-    }
-
-    const items = rows.map((row) => {
-      if (args.compact === "true") {
-        return {
-          id: row.id,
-          title: row.title,
-          isDefault: row.isDefault,
-        };
-      }
-      return {
-        id: row.id,
-        title: row.title,
-        description: row.description,
-        data: row.data,
-        isDefault: row.isDefault,
-        visibility: row.visibility,
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt,
-      };
-    });
-
-    return { count: items.length, designSystems: items };
-  },
-});

package/corpus/templates/videos/actions/list-folders.ts

@@ -1,61 +0,0 @@
-import { defineAction } from "@agent-native/core";
-import { accessFilter } from "@agent-native/core/sharing";
-import { and, desc, eq, inArray } from "drizzle-orm";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-
-export default defineAction({
-  description:
-    "List all library folders accessible to the current user, with the composition IDs filed into each.",
-  schema: z.object({}),
-  http: { method: "GET" },
-  run: async () => {
-    const db = getDb();
-
-    const folderRows = await db
-      .select()
-      .from(schema.folders)
-      .where(accessFilter(schema.folders, schema.folderShares))
-      .orderBy(desc(schema.folders.createdAt));
-
-    let memberships: { folderId: string; compositionId: string }[] = [];
-    if (folderRows.length > 0) {
-      const folderIds = folderRows.map((f) => f.id);
-      memberships = await db
-        .select({
-          folderId: schema.folderMemberships.folderId,
-          compositionId: schema.folderMemberships.compositionId,
-        })
-        .from(schema.folderMemberships)
-        .innerJoin(
-          schema.compositions,
-          eq(schema.folderMemberships.compositionId, schema.compositions.id),
-        )
-        .where(
-          and(
-            inArray(schema.folderMemberships.folderId, folderIds),
-            accessFilter(schema.compositions, schema.compositionShares),
-          ),
-        );
-    }
-
-    const compositionsByFolder = new Map<string, string[]>();
-    for (const m of memberships) {
-      const arr = compositionsByFolder.get(m.folderId) ?? [];
-      arr.push(m.compositionId);
-      compositionsByFolder.set(m.folderId, arr);
-    }
-
-    return folderRows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-      visibility: row.visibility,
-      ownerEmail: row.ownerEmail,
-      orgId: row.orgId,
-      compositionIds: compositionsByFolder.get(row.id) ?? [],
-    }));
-  },
-});

package/corpus/templates/videos/actions/move-composition-to-folder.ts

@@ -1,59 +0,0 @@
-import { defineAction } from "@agent-native/core";
-import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
-import { nanoid } from "nanoid";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-
-export default defineAction({
-  description:
-    "Move a composition into a folder, or pass folderId='' (or omit it) to remove the composition from its current folder.",
-  schema: z.object({
-    compositionId: z.string().describe("Composition id to file"),
-    folderId: z
-      .string()
-      .optional()
-      .describe(
-        "Target folder id. Empty string or omitted means 'remove from folder'.",
-      ),
-  }),
-  run: async ({ compositionId, folderId }) => {
-    const db = getDb();
-
-    const compositionAccess = await assertAccess(
-      "composition",
-      compositionId,
-      "editor",
-    );
-
-    let folderAccess: Awaited<ReturnType<typeof assertAccess>> | null = null;
-    if (folderId) {
-      folderAccess = await assertAccess("folder", folderId, "editor");
-      if (
-        compositionAccess.resource.orgId &&
-        folderAccess.resource.orgId &&
-        compositionAccess.resource.orgId !== folderAccess.resource.orgId
-      ) {
-        throw new Error("Composition and folder belong to different orgs");
-      }
-    }
-
-    await db
-      .delete(schema.folderMemberships)
-      .where(eq(schema.folderMemberships.compositionId, compositionId));
-
-    if (!folderId || !folderAccess) {
-      return { compositionId, folderId: null };
-    }
-
-    await db.insert(schema.folderMemberships).values({
-      id: nanoid(),
-      folderId,
-      compositionId,
-      createdAt: new Date().toISOString(),
-    });
-
-    return { compositionId, folderId };
-  },
-});

package/corpus/templates/videos/actions/navigate.ts

@@ -1,40 +0,0 @@
-/**
- * Navigate the UI to a composition or the studio home.
- *
- * Writes a navigate command to application state which the UI reads and auto-deletes.
- *
- * Usage:
- *   pnpm action navigate --view=home
- *   pnpm action navigate --compositionId=logo-reveal
- *
- * Options:
- *   --view            Navigate to a top-level view ("home", "components")
- *   --compositionId   Composition ID to open
- */
-
-import { defineAction } from "@agent-native/core";
-import { writeAppState } from "@agent-native/core/application-state";
-import { z } from "zod";
-
-export default defineAction({
-  description:
-    "Navigate the UI to a specific composition or view. Writes a navigate command to application state which the UI reads and auto-deletes.",
-  schema: z.object({
-    view: z
-      .string()
-      .optional()
-      .describe("Top-level view to navigate to (home, components)"),
-    compositionId: z.string().optional().describe("Composition ID to open"),
-  }),
-  http: false,
-  run: async (args) => {
-    if (!args.view && !args.compositionId) {
-      throw new Error("At least --view or --compositionId is required.");
-    }
-    const nav: Record<string, string> = {};
-    if (args.view) nav.view = args.view;
-    if (args.compositionId) nav.compositionId = args.compositionId;
-    await writeAppState("navigate", nav);
-    return `Navigating to ${args.view || ""}${args.compositionId ? ` composition:${args.compositionId}` : ""}`;
-  },
-});

package/corpus/templates/videos/actions/rename-folder.ts

@@ -1,41 +0,0 @@
-import { defineAction } from "@agent-native/core";
-import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
-import { z } from "zod";
-
-import { getDb, schema } from "../server/db/index.js";
-
-export default defineAction({
-  description: "Rename an existing library folder.",
-  schema: z.object({
-    id: z.string().describe("Folder id"),
-    name: z.string().describe("New folder name"),
-  }),
-  run: async ({ id, name }) => {
-    const trimmed = name.trim();
-    if (!trimmed) {
-      throw new Error("Folder name cannot be empty");
-    }
-
-    await assertAccess("folder", id, "editor");
-
-    const db = getDb();
-    const now = new Date().toISOString();
-
-    const result = await db
-      .update(schema.folders)
-      .set({ name: trimmed, updatedAt: now })
-      .where(eq(schema.folders.id, id))
-      .returning();
-
-    if (result.length === 0) {
-      throw new Error("Folder not found");
-    }
-
-    return {
-      id: result[0].id,
-      name: result[0].name,
-      updatedAt: result[0].updatedAt,
-    };
-  },
-});

package/corpus/templates/videos/actions/run.ts

@@ -1,2 +0,0 @@
-import { runScript } from "@agent-native/core/scripts";
-runScript();