supipowers 2.1.0 → 2.2.1

package/src/config/schema.ts

@@ -1,176 +1,142 @@
-import type { TSchema } from "@sinclair/typebox";
-import { Type } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
+import { z } from "zod/v4";
+import type { ZodType } from "zod/v4";
 import type { SupipowersConfig } from "../types.js";
 import { QualityGatesSchema } from "../quality/schemas.js";
 import { UltraPlanConfigSchema } from "../ultraplan/contracts.js";
+import { collectSchemaValidationErrors } from "../ai/schema-validation.js";
 
 const TAG_FORMAT_PATTERN = "^(?:(?!\\$\\{version\\}).)*\\$\\{version\\}(?:(?!\\$\\{version\\}).)*$";
 
 
-export const ConfigSchema = Type.Object(
+export const ConfigSchema = z.object(
   {
-    version: Type.String(),
-    quality: Type.Object(
+    version: z.string(),
+    quality: z.object(
       {
         gates: QualityGatesSchema,
       },
-      { additionalProperties: false },
-    ),
-    lsp: Type.Object(
+    ).strict(),
+    lsp: z.object(
       {
-        setupGuide: Type.Boolean(),
+        setupGuide: z.boolean(),
       },
-      { additionalProperties: false },
-    ),
-    qa: Type.Object(
+    ).strict(),
+    qa: z.object(
       {
-        framework: Type.Union([Type.String(), Type.Null()]),
-        e2e: Type.Boolean(),
+        framework: z.string().nullable(),
+        e2e: z.boolean(),
       },
-      { additionalProperties: false },
-    ),
-    release: Type.Object(
+    ).strict(),
+    release: z.object(
       {
-        channels: Type.Array(Type.String()),
-        tagFormat: Type.String({ pattern: TAG_FORMAT_PATTERN }),
-        customChannels: Type.Optional(
-          Type.Record(
-            Type.String(),
-            Type.Object({
-              label: Type.String(),
-              publishCommand: Type.String(),
-              detectCommand: Type.Optional(Type.String()),
-            }),
-          ),
-        ),
+        channels: z.array(z.string()),
+        tagFormat: z.string().regex(new RegExp(TAG_FORMAT_PATTERN)),
+        customChannels: z.record(
+          z.string(),
+          z.object({
+            label: z.string(),
+            publishCommand: z.string(),
+            detectCommand: z.string().optional(),
+          }),
+        ).optional(),
       },
-      { additionalProperties: false },
-    ),
+    ).strict(),
     ultraplan: UltraPlanConfigSchema,
-    contextMode: Type.Object(
+    contextMode: z.object(
       {
-        enabled: Type.Boolean(),
-        compressionThreshold: Type.Number({ minimum: 1024 }),
-        blockHttpCommands: Type.Boolean(),
-        routingInstructions: Type.Boolean(),
-        eventTracking: Type.Boolean(),
-        compaction: Type.Boolean(),
-        llmSummarization: Type.Boolean(),
-        llmThreshold: Type.Number({ minimum: 4096 }),
-        enforceRouting: Type.Boolean(),
-        lazyTools: Type.Object(
+        enabled: z.boolean(),
+        compressionThreshold: z.number().min(1024),
+        blockHttpCommands: z.boolean(),
+        routingInstructions: z.boolean(),
+        eventTracking: z.boolean(),
+        compaction: z.boolean(),
+        llmSummarization: z.boolean(),
+        llmThreshold: z.number().min(4096),
+        enforceRouting: z.boolean(),
+        lazyTools: z.object(
           {
-            enabled: Type.Boolean(),
-            mode: Type.Union([
-              Type.Literal("conservative"),
-              Type.Literal("balanced"),
-              Type.Literal("aggressive"),
-            ]),
-            alwaysKeep: Type.Array(Type.String()),
-            commandAllowlist: Type.Record(Type.String(), Type.Array(Type.String())),
-            keywordTools: Type.Record(Type.String(), Type.Array(Type.String())),
+            enabled: z.boolean(),
+            mode: z.enum(["conservative", "balanced", "aggressive"]),
+            alwaysKeep: z.array(z.string()),
+            commandAllowlist: z.record(z.string(), z.array(z.string())),
+            keywordTools: z.record(z.string(), z.array(z.string())),
           },
-          { additionalProperties: false },
-        ),
-        processors: Type.Object(
+        ).strict(),
+        processors: z.object(
           {
-            enabled: Type.Boolean(),
-            disable: Type.Array(
-              Type.Union([
-                Type.Literal("git"),
-                Type.Literal("test"),
-                Type.Literal("lint"),
-                Type.Literal("build"),
-                Type.Literal("k8s"),
-                Type.Literal("docker"),
-                Type.Literal("log"),
-                Type.Literal("json"),
-              ]),
+            enabled: z.boolean(),
+            disable: z.array(
+              z.enum(["git", "test", "lint", "build", "k8s", "docker", "log", "json"]),
             ),
           },
-          { additionalProperties: false },
-        ),
-        cacheHandles: Type.Object(
+        ).strict(),
+        cacheHandles: z.object(
           {
-            enabled: Type.Boolean(),
-            spillThresholdBytes: Type.Number({ minimum: 1024 }),
-            previewBytes: Type.Number({ minimum: 256 }),
+            enabled: z.boolean(),
+            spillThresholdBytes: z.number().min(1024),
+            previewBytes: z.number().min(256),
           },
-          { additionalProperties: false },
-        ),
-        repomap: Type.Object(
+        ).strict(),
+        repomap: z.object(
           {
-            enabled: Type.Boolean(),
-            tokenBudget: Type.Number({ minimum: 100 }),
-            maxFiles: Type.Number({ minimum: 1 }),
+            enabled: z.boolean(),
+            tokenBudget: z.number().min(100),
+            maxFiles: z.number().min(1),
           },
-          { additionalProperties: false },
-        ),
-        memory: Type.Object(
+        ).strict(),
+        memory: z.object(
           {
-            enabled: Type.Boolean(),
-            byteBudget: Type.Number({ minimum: 256 }),
-            maxRows: Type.Number({ minimum: 1 }),
-            retentionDays: Type.Number({ minimum: 1 }),
-            focusChainCadence: Type.Integer({ minimum: 1 }),
+            enabled: z.boolean(),
+            byteBudget: z.number().min(256),
+            maxRows: z.number().min(1),
+            retentionDays: z.number().min(1),
+            focusChainCadence: z.number().int().min(1),
           },
-          { additionalProperties: false },
-        ),
+        ).strict(),
       },
-      { additionalProperties: false },
-    ),
-    mempalace: Type.Object(
+    ).strict(),
+    mempalace: z.object(
       {
-        enabled: Type.Boolean(),
-        packageVersion: Type.String({ minLength: 1 }),
-        managedVenvPath: Type.String({ minLength: 1 }),
-        palacePath: Type.String({ minLength: 1 }),
-        defaultWingStrategy: Type.Union([
-          Type.Literal("repo-name"),
-          Type.Literal("project-slug"),
-          Type.Literal("explicit"),
-        ]),
-        explicitWing: Type.Union([Type.String(), Type.Null()]),
-        defaultAgentName: Type.String({ minLength: 1 }),
-        autoSetup: Type.Boolean(),
-        hooks: Type.Object(
+        enabled: z.boolean(),
+        packageVersion: z.string().min(1),
+        managedVenvPath: z.string().min(1),
+        palacePath: z.string().min(1),
+        defaultWingStrategy: z.enum(["repo-name", "project-slug", "explicit"]),
+        explicitWing: z.string().nullable(),
+        defaultAgentName: z.string().min(1),
+        autoSetup: z.boolean(),
+        hooks: z.object(
           {
-            wakeUp: Type.Boolean(),
-            searchGuidance: Type.Boolean(),
-            autoSearchOnPrompt: Type.Boolean(),
-            compactionCheckpoint: Type.Boolean(),
-            shutdownDiary: Type.Boolean(),
+            wakeUp: z.boolean(),
+            searchGuidance: z.boolean(),
+            autoSearchOnPrompt: z.boolean(),
+            compactionCheckpoint: z.boolean(),
+            shutdownDiary: z.boolean(),
           },
-          { additionalProperties: false },
-        ),
-        budgets: Type.Object(
+        ).strict(),
+        budgets: z.object(
           {
-            wakeUpTokens: Type.Integer({ minimum: 1 }),
-            searchResultChars: Type.Integer({ minimum: 1 }),
-            listResultChars: Type.Integer({ minimum: 1 }),
-            diaryChars: Type.Integer({ minimum: 1 }),
-            autoSearchTokens: Type.Integer({ minimum: 1 }),
-            wakeUpInjectionEvery: Type.Integer({ minimum: 1 }),
-            autoSearchSimilarityFloor: Type.Number({ minimum: 0, maximum: 1 }),
-            autoSearchBm25Floor: Type.Number({ minimum: 0 }),
+            wakeUpTokens: z.number().int().min(1),
+            searchResultChars: z.number().int().min(1),
+            listResultChars: z.number().int().min(1),
+            diaryChars: z.number().int().min(1),
+            autoSearchTokens: z.number().int().min(1),
+            wakeUpInjectionEvery: z.number().int().min(1),
+            autoSearchSimilarityFloor: z.number().min(0).max(1),
+            autoSearchBm25Floor: z.number().min(0),
           },
-          { additionalProperties: false },
-        ),
-        timeouts: Type.Object(
+        ).strict(),
+        timeouts: z.object(
           {
-            setupMs: Type.Integer({ minimum: 1 }),
-            bridgeMs: Type.Integer({ minimum: 1 }),
-            hookMs: Type.Integer({ minimum: 1 }),
+            setupMs: z.number().int().min(1),
+            bridgeMs: z.number().int().min(1),
+            hookMs: z.number().int().min(1),
           },
-          { additionalProperties: false },
-        ),
+        ).strict(),
       },
-      { additionalProperties: false },
-    ), 
+    ).strict(),
   },
-  { additionalProperties: false },
-);
+).strict();
 
 export interface ConfigParseError {
   source: "global" | "root";
@@ -190,13 +156,10 @@ export interface InspectionLoadResult {
   validationErrors: ConfigValidationError[];
 }
 
-function normalizeErrorPath(path: string): string {
-  return path.replace(/^\//, "").replace(/\//g, ".") || "(root)";
-}
 
-function collectValidationErrors(schema: TSchema, data: unknown): ConfigValidationError[] {
-  return [...Value.Errors(schema, data)].map((error) => ({
-    path: normalizeErrorPath(error.path),
+function collectValidationErrors(schema: ZodType, data: unknown): ConfigValidationError[] {
+  return collectSchemaValidationErrors(schema, data).map((error) => ({
+    path: error.path,
     message: error.message,
   }));
 }

package/src/context/rule-renderer.ts

@@ -1,7 +1,12 @@
-import type { RuleMode, WriteRuleAction } from "./startup-optimizer.js";
+import type { RuleMode, WriteCommandAction, WriteExtensionAction, WriteRuleAction } from "./startup-optimizer.js";
 
 export const MANAGED_RULE_HEADER = "<!-- supipowers:managed-rule";
 export const MANAGED_RULE_END = "-->";
+export const MANAGED_COMMAND_HEADER = "<!-- supipowers:managed-command";
+const MANAGED_COMMAND_FRONTMATTER_KEY = "supipowers-managed-command";
+const MANAGED_COMMAND_FRONTMATTER_VERSION = "1";
+export const MANAGED_EXTENSION_HEADER = "/* supipowers:managed-extension";
+export const MANAGED_EXTENSION_END = "*/";
 
 export interface ManagedRuleMetadata {
   version: number;
@@ -13,6 +18,26 @@ export interface ManagedRuleMetadata {
   sourceBytes: number;
 }
 
+export interface ManagedCommandMetadata {
+  version: number;
+  sourceId: string;
+  sourceName: string;
+  sourceHash: string;
+  slug: string;
+  commandName: string;
+  sourceBytes: number;
+}
+
+export interface ManagedExtensionMetadata {
+  version: number;
+  sourceId: string;
+  sourceName: string;
+  sourceHash: string;
+  slug: string;
+  extensionName: string;
+  sourceBytes: number;
+}
+
 export type ParsedManagedRule =
   | { status: "unmanaged"; managed: false }
   | {
@@ -29,6 +54,27 @@ export type ParsedManagedRule =
     }
   | { status: "malformed"; managed: true; error: string };
 
+export type ParsedManagedCommand =
+  | { status: "unmanaged"; managed: false }
+  | {
+      status: "managed";
+      managed: true;
+      metadata: ManagedCommandMetadata;
+      frontmatter: Record<string, string>;
+      body: string;
+    }
+  | { status: "malformed"; managed: true; error: string };
+
+export type ParsedManagedExtension =
+  | { status: "unmanaged"; managed: false }
+  | {
+      status: "managed";
+      managed: true;
+      metadata: ManagedExtensionMetadata;
+      body: string;
+    }
+  | { status: "malformed"; managed: true; error: string };
+
 /**
  * Render a managed rule file.
  *
@@ -56,6 +102,47 @@ export function renderManagedRule(action: WriteRuleAction): string {
   return `${metadata}\n---\n${frontmatter}\n---\n${body}`;
 }
 
+export function renderManagedCommand(action: WriteCommandAction): string {
+  const description = action.description ?? `Run ${action.sourceName} on demand.`;
+  const body = action.sourceContent.endsWith("\n")
+    ? action.sourceContent
+    : `${action.sourceContent}\n`;
+
+  return [
+    "---",
+    `description: ${frontmatterScalarLiteral(description)}`,
+    `${MANAGED_COMMAND_FRONTMATTER_KEY}: ${frontmatterScalarLiteral(MANAGED_COMMAND_FRONTMATTER_VERSION)}`,
+    `sourceId: ${frontmatterScalarLiteral(action.sourceId)}`,
+    `sourceName: ${frontmatterScalarLiteral(action.sourceName)}`,
+    `sourceHash: ${frontmatterScalarLiteral(action.sourceHash)}`,
+    `slug: ${frontmatterScalarLiteral(action.slug)}`,
+    `commandName: ${frontmatterScalarLiteral(action.commandName)}`,
+    `sourceBytes: ${action.sourceBytes}`,
+    "---",
+    body,
+  ].join("\n");
+}
+
+export function renderManagedExtension(action: WriteExtensionAction): string {
+  const metadata = [
+    MANAGED_EXTENSION_HEADER,
+    "version: 1",
+    `sourceId: ${action.sourceId}`,
+    `sourceName: ${action.sourceName}`,
+    `sourceHash: ${action.sourceHash}`,
+    `slug: ${action.slug}`,
+    `extensionName: ${action.extensionName}`,
+    `sourceBytes: ${action.sourceBytes}`,
+    MANAGED_EXTENSION_END,
+  ].join("\n");
+  const body = action.sourceContent.endsWith("\n")
+    ? action.sourceContent
+    : `${action.sourceContent}\n`;
+
+  return `${metadata}\n${body}`;
+}
+
+
 export function parseManagedRule(text: string): ParsedManagedRule {
   if (!text.startsWith(MANAGED_RULE_HEADER)) {
     return { status: "unmanaged", managed: false };
@@ -87,12 +174,98 @@ export function parseManagedRule(text: string): ParsedManagedRule {
   };
 }
 
+export function parseManagedCommand(text: string): ParsedManagedCommand {
+  if (text.startsWith(MANAGED_COMMAND_HEADER)) {
+    const headerEnd = text.indexOf(MANAGED_RULE_END, MANAGED_COMMAND_HEADER.length);
+    if (headerEnd === -1) {
+      return { status: "malformed", managed: true, error: "managed header is not closed" };
+    }
+
+    const headerText = text.slice(0, headerEnd).trimEnd();
+    const metadataResult = parseCommandMetadata(headerText);
+    if (typeof metadataResult === "string") {
+      return { status: "malformed", managed: true, error: metadataResult };
+    }
+
+    const afterHeader = text.slice(headerEnd + MANAGED_RULE_END.length).replace(/^\r?\n/, "");
+    const frontmatterResult = parseFrontmatter(afterHeader);
+    if (typeof frontmatterResult === "string") {
+      return { status: "malformed", managed: true, error: frontmatterResult };
+    }
+
+    return {
+      status: "managed",
+      managed: true,
+      metadata: metadataResult,
+      frontmatter: frontmatterResult.frontmatter,
+      body: stripTrailingNewline(frontmatterResult.body),
+    };
+  }
+
+  const frontmatterResult = parseFrontmatter(text);
+  if (typeof frontmatterResult === "string") {
+    if (
+      (text.startsWith("---\n") || text.startsWith("---\r\n")) &&
+      text.includes(`${MANAGED_COMMAND_FRONTMATTER_KEY}:`)
+    ) {
+      return { status: "malformed", managed: true, error: frontmatterResult };
+    }
+    return { status: "unmanaged", managed: false };
+  }
+
+  if (!frontmatterResult.frontmatter[MANAGED_COMMAND_FRONTMATTER_KEY]) {
+    return { status: "unmanaged", managed: false };
+  }
+
+  const metadataResult = parseCommandFrontmatterMetadata(frontmatterResult.frontmatter);
+  if (typeof metadataResult === "string") {
+    return { status: "malformed", managed: true, error: metadataResult };
+  }
+
+  return {
+    status: "managed",
+    managed: true,
+    metadata: metadataResult,
+    frontmatter: frontmatterResult.frontmatter,
+    body: stripTrailingNewline(frontmatterResult.body),
+  };
+}
+
+export function parseManagedExtension(text: string): ParsedManagedExtension {
+  if (!text.startsWith(MANAGED_EXTENSION_HEADER)) {
+    return { status: "unmanaged", managed: false };
+  }
+
+  const headerEnd = text.indexOf(MANAGED_EXTENSION_END, MANAGED_EXTENSION_HEADER.length);
+  if (headerEnd === -1) {
+    return { status: "malformed", managed: true, error: "managed extension header is not closed" };
+  }
+
+  const headerText = text.slice(0, headerEnd).trimEnd();
+  const metadataResult = parseExtensionMetadata(headerText);
+  if (typeof metadataResult === "string") {
+    return { status: "malformed", managed: true, error: metadataResult };
+  }
+
+  const body = text.slice(headerEnd + MANAGED_EXTENSION_END.length).replace(/^\r?\n/, "");
+  return {
+    status: "managed",
+    managed: true,
+    metadata: metadataResult,
+    body: stripTrailingNewline(body),
+  };
+}
+
 function renderFrontmatter(action: WriteRuleAction): string {
   if (action.mode === "ttsr") {
     if (!action.condition) {
       throw new Error(`TTSR rule ${action.slug} is missing a condition`);
     }
-    return `condition: ${frontmatterScalarLiteral(action.condition)}`;
+    return [
+      `condition: ${frontmatterScalarLiteral(action.condition)}`,
+      ...(action.triggers ? [`triggers: ${frontmatterScalarLiteral(action.triggers)}`] : []),
+      `scope: ${frontmatterScalarLiteral(action.scope ?? "text")}`,
+    ].join("\n");
   }
 
   const description = action.description ?? deriveRuleDescription(action.sourceContent) ?? `Use ${action.sourceName} when relevant.`;
@@ -165,6 +338,105 @@ function parseMetadata(headerText: string): ManagedRuleMetadata | string {
   };
 }
 
+function parseCommandMetadata(headerText: string): ManagedCommandMetadata | string {
+  const lines = headerText.split(/\r?\n/);
+  if (lines[0] !== MANAGED_COMMAND_HEADER) {
+    return "managed command header marker is invalid";
+  }
+
+  const raw: Record<string, string> = {};
+  for (const line of lines.slice(1)) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    raw[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+
+  return parseCommandMetadataFields(raw);
+}
+
+function parseCommandFrontmatterMetadata(frontmatter: Record<string, string>): ManagedCommandMetadata | string {
+  if (frontmatter[MANAGED_COMMAND_FRONTMATTER_KEY] !== MANAGED_COMMAND_FRONTMATTER_VERSION) {
+    return "managed command metadata has invalid version";
+  }
+
+  return parseCommandMetadataFields({
+    version: frontmatter[MANAGED_COMMAND_FRONTMATTER_KEY],
+    sourceId: frontmatter.sourceId,
+    sourceName: frontmatter.sourceName,
+    sourceHash: frontmatter.sourceHash,
+    slug: frontmatter.slug,
+    commandName: frontmatter.commandName,
+    sourceBytes: frontmatter.sourceBytes,
+  });
+}
+
+function parseCommandMetadataFields(raw: Record<string, string | undefined>): ManagedCommandMetadata | string {
+  const versionRaw = raw.version;
+  const sourceId = raw.sourceId;
+  const sourceName = raw.sourceName;
+  const sourceHash = raw.sourceHash;
+  const slug = raw.slug;
+  const commandName = raw.commandName;
+  const sourceBytesRaw = raw.sourceBytes;
+  if (!versionRaw) return "managed command metadata missing version";
+  if (!sourceId) return "managed command metadata missing sourceId";
+  if (!sourceName) return "managed command metadata missing sourceName";
+  if (!sourceHash) return "managed command metadata missing sourceHash";
+  if (!slug) return "managed command metadata missing slug";
+  if (!commandName) return "managed command metadata missing commandName";
+  if (!sourceBytesRaw) return "managed command metadata missing sourceBytes";
+
+  const version = Number(versionRaw);
+  const sourceBytes = Number(sourceBytesRaw);
+  if (!Number.isInteger(version) || version <= 0) return "managed command metadata has invalid version";
+  if (!Number.isInteger(sourceBytes) || sourceBytes < 0) return "managed command metadata has invalid sourceBytes";
+
+  return {
+    version,
+    sourceId,
+    sourceName,
+    sourceHash,
+    slug,
+    commandName,
+    sourceBytes,
+  };
+}
+
+function parseExtensionMetadata(headerText: string): ManagedExtensionMetadata | string {
+  const lines = headerText.split(/\r?\n/);
+  if (lines[0] !== MANAGED_EXTENSION_HEADER) {
+    return "managed extension header marker is invalid";
+  }
+
+  const raw: Record<string, string> = {};
+  for (const line of lines.slice(1)) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    raw[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+
+  const required = ["version", "sourceId", "sourceName", "sourceHash", "slug", "extensionName", "sourceBytes"];
+  for (const key of required) {
+    if (!raw[key]) return `managed extension metadata missing ${key}`;
+  }
+
+  const version = Number(raw.version);
+  const sourceBytes = Number(raw.sourceBytes);
+  if (!Number.isInteger(version) || version <= 0) return "managed extension metadata has invalid version";
+  if (!Number.isInteger(sourceBytes) || sourceBytes < 0) return "managed extension metadata has invalid sourceBytes";
+
+  return {
+    version,
+    sourceId: raw.sourceId,
+    sourceName: raw.sourceName,
+    sourceHash: raw.sourceHash,
+    slug: raw.slug,
+    extensionName: raw.extensionName,
+    sourceBytes,
+  };
+}
+
+
 function parseFrontmatter(text: string): { frontmatter: Record<string, string>; body: string } | string {
   if (!text.startsWith("---\n") && !text.startsWith("---\r\n")) {
     return "managed frontmatter is missing opening delimiter";