@tankpkg/sdk 0.11.0 → 0.13.0

package/dist/index.mjs

@@ -1694,6 +1694,61 @@ const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
 		});
 	};
 });
+const $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+	def.inclusive = false;
+	$ZodUnion.init(inst, def);
+	const _super = inst._zod.parse;
+	defineLazy(inst._zod, "propValues", () => {
+		const propValues = {};
+		for (const option of def.options) {
+			const pv = option._zod.propValues;
+			if (!pv || Object.keys(pv).length === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+			for (const [k, v] of Object.entries(pv)) {
+				if (!propValues[k]) propValues[k] = /* @__PURE__ */ new Set();
+				for (const val of v) propValues[k].add(val);
+			}
+		}
+		return propValues;
+	});
+	const disc = cached(() => {
+		const opts = def.options;
+		const map = /* @__PURE__ */ new Map();
+		for (const o of opts) {
+			const values = o._zod.propValues?.[def.discriminator];
+			if (!values || values.size === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
+			for (const v of values) {
+				if (map.has(v)) throw new Error(`Duplicate discriminator value "${String(v)}"`);
+				map.set(v, o);
+			}
+		}
+		return map;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isObject(input)) {
+			payload.issues.push({
+				code: "invalid_type",
+				expected: "object",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const opt = disc.value.get(input?.[def.discriminator]);
+		if (opt) return opt._zod.run(payload, ctx);
+		if (def.unionFallback) return _super(payload, ctx);
+		payload.issues.push({
+			code: "invalid_union",
+			errors: [],
+			note: "No matching discriminator",
+			discriminator: def.discriminator,
+			input,
+			path: [def.discriminator],
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -3658,6 +3713,18 @@ function union(options, params) {
 		...normalizeParams(params)
 	});
 }
+const ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
+	ZodUnion.init(inst, def);
+	$ZodDiscriminatedUnion.init(inst, def);
+});
+function discriminatedUnion(discriminator, options, params) {
+	return new ZodDiscriminatedUnion({
+		type: "union",
+		options,
+		discriminator,
+		...normalizeParams(params)
+	});
+}
 const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
 	$ZodIntersection.init(inst, def);
 	ZodType.init(inst, def);
@@ -3908,6 +3975,159 @@ const REGISTRY_URL = process.env.TANK_REGISTRY_URL || "https://www.tankpkg.dev";
 const MANIFEST_FILENAME = "tank.json";
 const LEGACY_MANIFEST_FILENAME = "skills.json";
 const LOCKFILE_FILENAME = "tank.lock";
+const supportLevelSchema = _enum([
+	"full",
+	"degraded",
+	"none"
+]);
+const adapterCapabilitiesSchema = object({
+	instruction: supportLevelSchema,
+	hook: supportLevelSchema,
+	tool: supportLevelSchema,
+	agent: supportLevelSchema,
+	rule: supportLevelSchema,
+	resource: supportLevelSchema,
+	prompt: supportLevelSchema
+}).strict();
+const compilationWarningSchema = object({
+	level: _enum(["degraded", "skipped"]),
+	atomKind: string(),
+	message: string()
+}).strict();
+object({
+	files: array(object({
+		path: string().min(1),
+		content: string()
+	}).strict()),
+	warnings: array(compilationWarningSchema)
+}).strict();
+object({
+	name: string().min(1, "Adapter name must not be empty"),
+	supportedRange: string().min(1, "Supported range must not be empty"),
+	capabilities: adapterCapabilitiesSchema
+}).strict();
+_enum([
+	"instruction",
+	"hook",
+	"tool",
+	"agent",
+	"rule",
+	"resource",
+	"prompt"
+]);
+const extensionBagSchema = record(string(), unknown()).optional();
+const modelTierSchema = _enum([
+	"fast",
+	"balanced",
+	"powerful",
+	"custom"
+]);
+modelTierSchema.options;
+const canonicalToolNameSchema = _enum([
+	"bash",
+	"read",
+	"write",
+	"edit",
+	"grep",
+	"glob",
+	"lsp",
+	"mcp",
+	"browser",
+	"fetch",
+	"git",
+	"task",
+	"notebook"
+]);
+canonicalToolNameSchema.options;
+const agentIRSchema = object({
+	kind: literal("agent"),
+	name: string().min(1, "Agent name must not be empty"),
+	role: string().min(1, "Agent role must not be empty"),
+	tools: array(canonicalToolNameSchema.or(string().min(1))).optional(),
+	model: modelTierSchema.or(string().min(1)).optional(),
+	readonly: boolean().optional(),
+	extensions: extensionBagSchema
+}).strict();
+const hookEventSchema = _enum([
+	"pre-tool-use",
+	"post-tool-use",
+	"pre-file-read",
+	"post-file-read",
+	"pre-file-write",
+	"post-file-write",
+	"file-edited",
+	"file-watcher-updated",
+	"pre-command",
+	"post-command",
+	"pre-mcp-tool-use",
+	"post-mcp-tool-use",
+	"session-created",
+	"session-updated",
+	"session-idle",
+	"session-error",
+	"session-deleted",
+	"pre-stop",
+	"task-start",
+	"task-resume",
+	"task-complete",
+	"task-cancel",
+	"pre-user-prompt",
+	"post-response",
+	"message-updated",
+	"message-removed",
+	"system-prompt-transform",
+	"pre-context-compact",
+	"post-context-compact",
+	"permission-asked",
+	"permission-replied",
+	"lsp-diagnostics",
+	"lsp-updated",
+	"subagent-start",
+	"subagent-complete",
+	"subagent-tool-use",
+	"shell-env",
+	"todo-updated",
+	"installation-updated"
+]);
+hookEventSchema.options;
+const hookActionIRSchema = object({
+	action: _enum([
+		"block",
+		"allow",
+		"rewrite",
+		"injectContext"
+	]),
+	match: string().optional(),
+	reason: string().optional(),
+	value: string().optional()
+}).strict();
+const hookHandlerIRSchema = discriminatedUnion("type", [object({
+	type: literal("dsl"),
+	actions: array(hookActionIRSchema).min(1, "DSL handler must have at least one action")
+}).strict(), object({
+	type: literal("js"),
+	entry: string().min(1, "JS handler entry path must not be empty")
+}).strict()]);
+const hookIRSchema = object({
+	kind: literal("hook"),
+	name: string().optional(),
+	event: hookEventSchema,
+	match: canonicalToolNameSchema.or(string().min(1)).optional(),
+	handler: hookHandlerIRSchema,
+	scope: _enum(["project", "global"]).optional(),
+	extensions: extensionBagSchema
+}).strict();
+const instructionIRSchema = object({
+	kind: literal("instruction"),
+	content: string().min(1, "Content path must not be empty"),
+	scope: _enum([
+		"project",
+		"global",
+		"directory"
+	]).optional(),
+	globs: array(string()).optional(),
+	extensions: extensionBagSchema
+}).strict();
 const networkPermissionsSchema = object({ outbound: array(string()).optional() }).strict();
 const filesystemPermissionsSchema = object({
 	read: array(string()).optional(),
@@ -3946,7 +4166,77 @@ _enum([
 	"org.member.remove",
 	"org.delete"
 ]);
+const promptIRSchema = object({
+	kind: literal("prompt"),
+	name: string().min(1, "Prompt name must not be empty"),
+	description: string().optional(),
+	template: string().min(1, "Prompt template path must not be empty"),
+	arguments: array(object({
+		name: string(),
+		description: string().optional(),
+		required: boolean().optional()
+	}).strict()).optional(),
+	extensions: extensionBagSchema
+}).strict();
+const resourceIRSchema = object({
+	kind: literal("resource"),
+	name: string().optional(),
+	uri: string().min(1, "Resource URI must not be empty"),
+	description: string().optional(),
+	mimeType: string().optional(),
+	extensions: extensionBagSchema
+}).strict();
+const ruleIRSchema = object({
+	kind: literal("rule"),
+	name: string().optional(),
+	event: hookEventSchema,
+	match: canonicalToolNameSchema.or(string().min(1)).optional(),
+	policy: _enum([
+		"block",
+		"allow",
+		"warn"
+	]),
+	reason: string().optional(),
+	extensions: extensionBagSchema
+}).strict();
+const mcpServerConfigSchema = object({
+	command: string().min(1).optional(),
+	args: array(string()).optional(),
+	env: record(string(), string()).optional(),
+	runtime: string().min(1).optional(),
+	entry: string().min(1).optional()
+}).strict().refine((data) => data.command || data.runtime && data.entry, "MCP config must have either \"command\" or both \"runtime\" and \"entry\"");
+const toolIRSchema = object({
+	kind: literal("tool"),
+	name: string().min(1, "Tool name must not be empty"),
+	description: string().optional(),
+	mcp: mcpServerConfigSchema.optional(),
+	extensions: extensionBagSchema
+}).strict();
+const NAME_PATTERN = /^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/;
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+const atomIRSchema = discriminatedUnion("kind", [
+	instructionIRSchema,
+	hookIRSchema,
+	toolIRSchema,
+	agentIRSchema,
+	ruleIRSchema,
+	resourceIRSchema,
+	promptIRSchema
+]);
 object({
+	name: string().min(1, "Name must not be empty").max(214, `Name must be 214 characters or fewer`).regex(NAME_PATTERN, "Name must be scoped (@org/name), lowercase alphanumeric and hyphens"),
+	version: string().regex(SEMVER_PATTERN, "Version must be valid semver"),
+	description: string().max(500).optional(),
+	atoms: array(atomIRSchema),
+	includes: array(string()).optional(),
+	skills: record(string(), string()).optional(),
+	permissions: permissionsSchema.optional(),
+	repository: string().url("Repository must be a valid URL").optional(),
+	visibility: _enum(["public", "private"]).optional(),
+	audit: object({ min_score: number().min(0).max(10) }).strict().optional()
+}).strict();
+const baseManifestFields = {
 	name: string().min(1, "Name must not be empty").max(214, `Name must be 214 characters or fewer`).regex(/^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/, "Name must be scoped (@org/name), lowercase alphanumeric and hyphens"),
 	version: string().regex(/^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/, "Version must be valid semver"),
 	description: string().max(500, `Description must be 500 characters or fewer`).optional(),
@@ -3955,7 +4245,29 @@ object({
 	repository: string().url("Repository must be a valid URL").optional(),
 	visibility: _enum(["public", "private"]).optional(),
 	audit: object({ min_score: number().min(0).max(10) }).strict().optional()
+};
+object(baseManifestFields).strict();
+object({
+	...baseManifestFields,
+	atoms: array(record(string(), unknown())).optional(),
+	includes: array(string()).optional()
 }).strict();
+const SKILL_SOURCES = [
+	"registry",
+	"github",
+	"clawhub",
+	"skills_sh",
+	"agentskills_il",
+	"npm",
+	"local"
+];
+const SCAN_VERDICTS = [
+	"pass",
+	"pass_with_notes",
+	"flagged",
+	"fail",
+	"error"
+];
 const lockedSkillV1Schema = object({
 	resolved: string().url(),
 	integrity: string().regex(/^sha512-/, "Integrity must start with sha512-"),
@@ -3971,7 +4283,10 @@ const lockedSkillSchema = object({
 	integrity: string().regex(/^sha512-/, "Integrity must start with sha512-"),
 	permissions: permissionsSchema,
 	audit_score: number().min(0).max(10).nullable(),
-	dependencies: record(string(), string()).optional()
+	dependencies: record(string(), string()).optional(),
+	source: _enum(SKILL_SOURCES).optional(),
+	scan_verdict: _enum(SCAN_VERDICTS).optional(),
+	scanned_at: string().optional()
 });
 object({
 	lockfileVersion: union([literal(1), literal(2)]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tankpkg/sdk",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Official TypeScript SDK for the Tank registry — search, download, install, and audit AI agent skills programmatically",
   "type": "module",
   "exports": {