@appstrate/validation 1.1.1 → 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.1.1",
+  "version": "1.3.0",
   "type": "module",
   "files": [
     "src"

package/src/index.ts

@@ -26,14 +26,14 @@ export const jsonSchemaObjectSchema = z.object({
   propertyOrder: z.array(z.string()).optional(),
 });
 
-export const serviceRequirementSchema = z.object({
+export const serviceRequirementSchema = z.looseObject({
   id: z.string().min(1).regex(SLUG_REGEX, {
     error: "Must be a valid slug (a-z, 0-9, hyphens, no leading/trailing hyphen)",
   }),
   provider: z.string(),
   description: z.string().optional(),
-  scopes: z.array(z.string()).optional().default([]),
-  connectionMode: z.enum(["user", "admin"]).optional().default("user"),
+  scopes: z.array(z.string()).optional(),
+  connectionMode: z.enum(["user", "admin"]).optional(),
 });
 
 const slugString = z.string().min(1).regex(SLUG_REGEX, {
@@ -45,9 +45,9 @@ const semverRangeString = z.string().refine((val) => semver.validRange(val) !==
 });
 
 const registryDependenciesSchema = z
-  .object({
-    skills: z.record(z.string(), semverRangeString).optional().default({}),
-    extensions: z.record(z.string(), semverRangeString).optional().default({}),
+  .looseObject({
+    skills: z.record(z.string(), semverRangeString).optional(),
+    extensions: z.record(z.string(), semverRangeString).optional(),
   })
   .optional();
 
@@ -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.object({
+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.object({
   registryDependencies: registryDependenciesSchema,
 });
 
-export type BaseManifest = z.infer<typeof baseManifestSchema>;
+export type Manifest = z.infer<typeof manifestSchema>;
 
 // ─── Sub-schema inferred types ───────────────
 
@@ -82,14 +83,14 @@ export type FlowJsonSchemaProperty = z.infer<typeof jsonSchemaPropertySchema>;
 export type FlowJsonSchemaObject = z.infer<typeof jsonSchemaObjectSchema>;
 
 // ─────────────────────────────────────────────
-// Shared flow fields — used by both flowManifestSchema and localFlowManifestSchema
+// Shared flow fields
 // ─────────────────────────────────────────────
 
 const flowSharedFields = {
-  requires: z.object({
+  requires: z.looseObject({
     services: z.array(serviceRequirementSchema),
-    skills: z.array(slugString).optional().default([]),
-    extensions: z.array(slugString).optional().default([]),
+    skills: z.array(slugString).optional(),
+    extensions: z.array(slugString).optional(),
   }),
   input: z
     .object({
@@ -107,7 +108,7 @@ const flowSharedFields = {
     })
     .optional(),
   execution: z
-    .object({
+    .looseObject({
       timeout: z.number().optional(),
       outputRetries: z.number().min(0).max(5).optional(),
     })
@@ -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,34 +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 — try flow manifest validation (backward compat for flow-only manifests
-  // that don't have name/version/type because they rely on the old format)
-  return validateFlowManifest(raw);
-}
-
-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 };
   }
@@ -169,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 (
@@ -233,39 +222,6 @@ function countParams(paramStr: string): number {
   return count;
 }
 
-// ─────────────────────────────────────────────
-// Local flow manifest schema — relaxed for strate (no scoped name, optional version)
-// ─────────────────────────────────────────────
-
-export const localFlowManifestSchema = z.looseObject({
-  $schema: z.string().optional(),
-  schemaVersion: z.string(),
-  name: slugString,
-  displayName: z.string().min(1),
-  description: z.string(),
-  author: z.string(),
-  license: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  type: z.string().optional(),
-  version: z.string().optional(),
-  ...flowSharedFields,
-});
-
-export type LocalFlowManifest = z.infer<typeof localFlowManifestSchema>;
-
-export function validateLocalFlowManifest(raw: unknown): {
-  valid: boolean;
-  errors: string[];
-  manifest?: unknown;
-} {
-  const result = localFlowManifestSchema.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 };
-}
-
 export function validateExtensionSource(source: string): ExtensionValidationResult {
   const errors: string[] = [];
   const warnings: string[] = [];

package/src/naming.ts

@@ -9,24 +9,15 @@ 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(/^@([^/]+)\/(.+)$/);
+  if (!match) return null;
+  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,10 +139,9 @@ export function parsePackageZip(zipBuffer: Uint8Array, maxSize?: number): Parsed
     );
   }
 
-  const manifest = validation.manifest as Record<string, unknown>;
+  const manifest = validation.manifest!;
 
-  // Determine type (fallback "flow" for legacy manifests without type)
-  const type = (manifest.type as "flow" | "skill" | "extension") ?? "flow";
+  const type = manifest.type;
 
   // Extract primary content based on type
   let content: string;