@appstrate/validation 1.2.0 → 1.3.0

package/README.md

@@ -37,11 +37,10 @@ if (result.valid) {
 }
 ```
 
-Three manifest schemas are available:
+Two manifest schemas are available:
 
 - **`baseManifestSchema`** — Common fields for all types: `name` (`@scope/package-name`), `version` (semver), `type` (`flow` | `skill` | `extension`), optional `description`, `keywords`, `license`, `registryDependencies`
 - **`flowManifestSchema`** — Extends base with flow-specific fields: `schemaVersion`, `displayName`, `author`, `requires` (services, skills, extensions), `input`/`output`/`config` schemas, `execution` options
-- **`localFlowManifestSchema`** — Relaxed schema for strate built-in flows (slug name instead of scoped, optional version)
 
 ### Skill & Extension Validation
 
@@ -130,7 +129,7 @@ const sri = computeIntegrity(zipBuffer);
 │   ├── dependencies.ts   # extractDependencies, DepEntry type
 │   └── integrity.ts      # computeIntegrity (SHA256 SRI hash)
 │
-├── tests/                # bun:test (63 tests across 5 files)
+├── tests/                # bun:test (66 tests across 5 files)
 │   ├── index.test.ts     # Manifest validation (flow, skill, extension, base)
 │   ├── zip.test.ts       # ZIP parsing, folder detection, error codes, security
 │   ├── naming.test.ts    # Naming helpers, packageId conversion
@@ -145,7 +144,7 @@ const sri = computeIntegrity(zipBuffer);
 ## Development
 
 ```sh
-bun test             # Run all tests (63 tests, 5 files)
+bun test             # Run all tests (66 tests, 5 files)
 bun run check        # TypeScript type-check + ESLint + Prettier
 bun run lint         # ESLint only
 bun run format       # Prettier format

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appstrate/validation",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "files": [
     "src"

package/src/index.ts

@@ -59,12 +59,13 @@ export const scopedNameRegex = /^@[a-z0-9]([a-z0-9-]*[a-z0-9])?\/[a-z0-9]([a-z0-
 export const packageTypeEnum = z.enum(["flow", "skill", "extension"]);
 export type PackageType = z.infer<typeof packageTypeEnum>;
 
-export const baseManifestSchema = z.looseObject({
+export const manifestSchema = z.looseObject({
   name: z.string().regex(scopedNameRegex, { error: "Must follow the format @scope/package-name" }),
   version: z.string().refine((v) => semver.valid(v) !== null, {
     error: "Must be a valid semver version",
   }),
   type: packageTypeEnum,
+  displayName: z.string().optional().catch(undefined),
   description: z.string().optional().catch(undefined),
   keywords: z.array(z.string()).optional().catch(undefined),
   license: z.string().optional().catch(undefined),
@@ -73,7 +74,7 @@ export const baseManifestSchema = z.looseObject({
   registryDependencies: registryDependenciesSchema,
 });
 
-export type BaseManifest = z.infer<typeof baseManifestSchema>;
+export type Manifest = z.infer<typeof manifestSchema>;
 
 // ─── Sub-schema inferred types ───────────────
 
@@ -118,7 +119,7 @@ const flowSharedFields = {
 // Flow manifest schema — extends base with flow-specific fields
 // ─────────────────────────────────────────────
 
-export const flowManifestSchema = baseManifestSchema.extend({
+export const flowManifestSchema = manifestSchema.extend({
   $schema: z.string().optional(),
   schemaVersion: z.string(),
   displayName: z.string().min(1),
@@ -134,33 +135,14 @@ export type FlowManifest = z.infer<typeof flowManifestSchema>;
 // ─────────────────────────────────────────────
 
 export type ValidateManifestResult =
-  | { valid: true; errors: []; manifest: BaseManifest | FlowManifest }
+  | { valid: true; errors: []; manifest: Manifest | FlowManifest }
   | { valid: false; errors: string[]; manifest?: undefined };
 
-export function validateManifest(raw: unknown): ValidateManifestResult {
-  // First, check if it has a type field to dispatch
-  if (raw && typeof raw === "object" && "type" in raw) {
-    const obj = raw as Record<string, unknown>;
-
-    if (obj.type === "flow") {
-      return validateFlowManifest(raw);
-    }
-
-    // For skill/extension, validate with base schema only
-    const result = baseManifestSchema.safeParse(raw);
-    if (result.success) {
-      return { valid: true, errors: [], manifest: result.data };
-    }
-    const errors = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
-    return { valid: false, errors };
-  }
-
-  // No type field — require it explicitly
-  return { valid: false, errors: ["type: Required field is missing"] };
-}
-
-function validateFlowManifest(raw: unknown): ValidateManifestResult {
-  const result = flowManifestSchema.safeParse(raw);
+function parseWithSchema(
+  schema: typeof manifestSchema | typeof flowManifestSchema,
+  raw: unknown,
+): ValidateManifestResult {
+  const result = schema.safeParse(raw);
   if (result.success) {
     return { valid: true, errors: [], manifest: result.data };
   }
@@ -168,6 +150,14 @@ function validateFlowManifest(raw: unknown): ValidateManifestResult {
   return { valid: false, errors };
 }
 
+export function validateManifest(raw: unknown): ValidateManifestResult {
+  if (raw && typeof raw === "object" && "type" in raw) {
+    const schema = (raw as Record<string, unknown>).type === "flow" ? flowManifestSchema : manifestSchema;
+    return parseWithSchema(schema, raw);
+  }
+  return { valid: false, errors: ["type: Required field is missing"] };
+}
+
 function stripQuotes(value: string): string {
   const trimmed = value.trim();
   if (

package/src/naming.ts

@@ -9,13 +9,6 @@ export function stripScope(scope: string): string {
   return scope.startsWith("@") ? scope.slice(1) : scope;
 }
 
-/** Convert "@scope/name" to strate packageId "scope--name" */
-export function scopedNameToPackageId(scopedName: string): string {
-  const match = scopedName.match(/^@([a-z0-9][a-z0-9-]*[a-z0-9]?)\/([a-z0-9][a-z0-9-]*[a-z0-9]?)$/);
-  if (!match) throw new Error(`Invalid scoped package name: ${scopedName}`);
-  return `${match[1]}--${match[2]}`;
-}
-
 /** Parse "@scope/name" into { scope, name } or null if invalid */
 export function parseScopedName(scopedName: string): { scope: string; name: string } | null {
   const match = scopedName.match(/^@([^/]+)\/(.+)$/);
@@ -23,17 +16,8 @@ export function parseScopedName(scopedName: string): { scope: string; name: stri
   return { scope: match[1]!, name: match[2]! };
 }
 
-/** Convert strate packageId "scope--name" to "@scope/name", or null for local slugs */
-export function packageIdToScopedName(packageId: string): string | null {
-  const idx = packageId.indexOf("--");
-  if (idx === -1) return null;
-  const scope = packageId.slice(0, idx);
-  const name = packageId.slice(idx + 2);
-  if (!scope || !name) return null;
-  return `@${scope}/${name}`;
-}
-
-/** Convert separated scope + name to strate packageId */
-export function depEntryToPackageId(depScope: string, depName: string): string {
-  return `${stripScope(depScope)}--${depName}`;
+/** Build a packageId from separated scope + name. */
+export function buildPackageId(scope: string, name: string): string {
+  const s = stripScope(scope);
+  return `@${s}/${name}`;
 }

package/src/zip.ts

@@ -1,5 +1,11 @@
 import { unzipSync, zipSync, type Zippable } from "fflate";
-import { validateManifest, extractSkillMeta, validateExtensionSource } from "./index.ts";
+import {
+  validateManifest,
+  extractSkillMeta,
+  validateExtensionSource,
+  type Manifest,
+  type FlowManifest,
+} from "./index.ts";
 
 export type { Zippable };
 
@@ -62,7 +68,7 @@ function getFileText(
 // ─────────────────────────────────────────────
 
 export interface ParsedPackageZip {
-  manifest: Record<string, unknown>;
+  manifest: Manifest | FlowManifest;
   content: string;
   files: Record<string, Uint8Array>;
   type: "flow" | "skill" | "extension";
@@ -133,9 +139,9 @@ export function parsePackageZip(zipBuffer: Uint8Array, maxSize?: number): Parsed
     );
   }
 
-  const manifest = manifestRaw as Record<string, unknown>;
+  const manifest = validation.manifest!;
 
-  const type = manifest.type as "flow" | "skill" | "extension";
+  const type = manifest.type;
 
   // Extract primary content based on type
   let content: string;