supipowers 1.5.2 → 2.0.0

package/src/config/schema.ts

@@ -1,12 +1,13 @@
-// src/config/schema.ts
 import type { TSchema } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import type { SupipowersConfig } from "../types.js";
 import { QualityGatesSchema } from "../quality/schemas.js";
+import { UltraPlanConfigSchema } from "../ultraplan/contracts.js";
 
 const TAG_FORMAT_PATTERN = "^(?:(?!\\$\\{version\\}).)*\\$\\{version\\}(?:(?!\\$\\{version\\}).)*$";
 
+
 export const ConfigSchema = Type.Object(
   {
     version: Type.String(),
@@ -46,6 +47,7 @@ export const ConfigSchema = Type.Object(
       },
       { additionalProperties: false },
     ),
+    ultraplan: UltraPlanConfigSchema,
     contextMode: Type.Object(
       {
         enabled: Type.Boolean(),
@@ -57,6 +59,64 @@ export const ConfigSchema = Type.Object(
         llmSummarization: Type.Boolean(),
         llmThreshold: Type.Number({ minimum: 4096 }),
         enforceRouting: Type.Boolean(),
+        lazyTools: Type.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())),
+          },
+          { additionalProperties: false },
+        ),
+        processors: Type.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"),
+              ]),
+            ),
+          },
+          { additionalProperties: false },
+        ),
+        cacheHandles: Type.Object(
+          {
+            enabled: Type.Boolean(),
+            spillThresholdBytes: Type.Number({ minimum: 1024 }),
+            previewBytes: Type.Number({ minimum: 256 }),
+          },
+          { additionalProperties: false },
+        ),
+        repomap: Type.Object(
+          {
+            enabled: Type.Boolean(),
+            tokenBudget: Type.Number({ minimum: 100 }),
+            maxFiles: Type.Number({ minimum: 1 }),
+          },
+          { additionalProperties: false },
+        ),
+        memory: Type.Object(
+          {
+            enabled: Type.Boolean(),
+            byteBudget: Type.Number({ minimum: 256 }),
+            maxRows: Type.Number({ minimum: 1 }),
+            retentionDays: Type.Number({ minimum: 1 }),
+            focusChainCadence: Type.Integer({ minimum: 1 }),
+          },
+          { additionalProperties: false },
+        ),
       },
       { additionalProperties: false },
     ),
@@ -66,12 +126,58 @@ export const ConfigSchema = Type.Object(
       },
       { additionalProperties: false },
     ),
+    mempalace: Type.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(
+          {
+            wakeUp: Type.Boolean(),
+            searchGuidance: Type.Boolean(),
+            autoSearchOnPrompt: Type.Boolean(),
+            compactionCheckpoint: Type.Boolean(),
+            shutdownDiary: Type.Boolean(),
+          },
+          { additionalProperties: false },
+        ),
+        budgets: Type.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 }),
+          },
+          { additionalProperties: false },
+        ),
+        timeouts: Type.Object(
+          {
+            setupMs: Type.Integer({ minimum: 1 }),
+            bridgeMs: Type.Integer({ minimum: 1 }),
+            hookMs: Type.Integer({ minimum: 1 }),
+          },
+          { additionalProperties: false },
+        ),
+      },
+      { additionalProperties: false },
+    ), 
   },
   { additionalProperties: false },
 );
 
 export interface ConfigParseError {
-  source: "global" | "project";
+  source: "global" | "root";
   path: string;
   message: string;
 }

package/src/context/optimizer.ts

@@ -1,3 +1,5 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type { Platform } from "../platform/types.js";
 import type { ParsedSkill, PromptSection } from "./analyzer.js";
 import { estimateTokens } from "./analyzer.js";
@@ -56,24 +58,20 @@ const DEP_TO_TOOL: Record<string, string> = {
 
 // ── Tech Stack Detection ────────────────────────────────────
 
-/** Read a file via platform.exec; returns content or null on failure. */
-async function tryRead(
-  platform: Platform,
-  cwd: string,
-  filename: string,
-): Promise<string | null> {
-  const r = await platform.exec("cat", [filename], { cwd });
-  return r.code === 0 ? r.stdout : null;
+function tryReadFile(cwd: string, filename: string): string | null {
+  try {
+    return fs.readFileSync(path.join(cwd, filename), "utf8");
+  } catch {
+    return null;
+  }
 }
 
-/** Check if a file exists at `cwd/filename` via exec. */
-async function fileExists(
-  platform: Platform,
-  cwd: string,
-  filename: string,
-): Promise<boolean> {
-  const r = await platform.exec("test", ["-f", filename], { cwd });
-  return r.code === 0;
+function fileExists(cwd: string, filename: string): boolean {
+  try {
+    return fs.statSync(path.join(cwd, filename)).isFile();
+  } catch {
+    return false;
+  }
 }
 
 /**
@@ -84,13 +82,14 @@ export async function detectTechStack(
   platform: Platform,
   cwd: string,
 ): Promise<TechStack> {
+  void platform;
+
   const languages = new Set<string>();
   const frameworks = new Set<string>();
   const tools = new Set<string>();
   let runtime: string | null = null;
 
-  // 1. package.json — deps & devDeps
-  const pkgRaw = await tryRead(platform, cwd, "package.json");
+  const pkgRaw = tryReadFile(cwd, "package.json");
   if (pkgRaw) {
     try {
       const pkg = JSON.parse(pkgRaw);
@@ -110,18 +109,16 @@ export async function detectTechStack(
     }
   }
 
-  // 2. Lockfiles → runtime (first match wins, most-specific first)
-  if (await fileExists(platform, cwd, "bun.lock")) {
+  if (fileExists(cwd, "bun.lock")) {
     runtime = "bun";
-  } else if (await fileExists(platform, cwd, "package-lock.json")) {
+  } else if (fileExists(cwd, "package-lock.json")) {
     runtime = "node";
-  } else if (await fileExists(platform, cwd, "pnpm-lock.yaml")) {
+  } else if (fileExists(cwd, "pnpm-lock.yaml")) {
     runtime = "node";
-  } else if (await fileExists(platform, cwd, "yarn.lock")) {
+  } else if (fileExists(cwd, "yarn.lock")) {
     runtime = "node";
   }
 
-  // 3. Config files → languages
   const configChecks: [string, string][] = [
     ["tsconfig.json", "typescript"],
     ["Cargo.toml", "rust"],
@@ -130,15 +127,10 @@ export async function detectTechStack(
     ["go.mod", "go"],
     ["Gemfile", "ruby"],
   ];
-  const results = await Promise.all(
-    configChecks.map(([file, lang]) =>
-      fileExists(platform, cwd, file).then((exists) =>
-        exists ? lang : null,
-      ),
-    ),
-  );
-  for (const lang of results) {
-    if (lang) languages.add(lang);
+  for (const [file, language] of configChecks) {
+    if (fileExists(cwd, file)) {
+      languages.add(language);
+    }
   }
 
   return {

package/src/context/rule-renderer.ts

@@ -0,0 +1,223 @@
+import type { RuleMode, WriteRuleAction } from "./startup-optimizer.js";
+
+export const MANAGED_RULE_HEADER = "<!-- supipowers:managed-rule";
+export const MANAGED_RULE_END = "-->";
+
+export interface ManagedRuleMetadata {
+  version: number;
+  mode: RuleMode;
+  sourceId: string;
+  sourceName: string;
+  sourceHash: string;
+  slug: string;
+  sourceBytes: number;
+}
+
+export type ParsedManagedRule =
+  | { status: "unmanaged"; managed: false }
+  | {
+      status: "managed";
+      managed: true;
+      metadata: ManagedRuleMetadata;
+      frontmatter: Record<string, string>;
+      /**
+       * Canonical source body — exactly what the optimizer hashed/sized to produce
+       * `metadata.sourceHash` / `metadata.sourceBytes`. Trailing newline added by the
+       * renderer (for POSIX-friendly EOF) is stripped during parsing.
+       */
+      body: string;
+    }
+  | { status: "malformed"; managed: true; error: string };
+
+/**
+ * Render a managed rule file.
+ *
+ * The body is written exactly as `action.sourceContent`, plus a single trailing newline
+ * if missing (POSIX-friendly EOF). The parser strips that trailing newline so
+ * `parsed.body` equals the canonical source content used to compute the manifest hash.
+ */
+export function renderManagedRule(action: WriteRuleAction): string {
+  const frontmatter = renderFrontmatter(action);
+  const metadata = [
+    MANAGED_RULE_HEADER,
+    "version: 1",
+    `mode: ${action.mode}`,
+    `sourceId: ${action.sourceId}`,
+    `sourceName: ${action.sourceName}`,
+    `sourceHash: ${action.sourceHash}`,
+    `slug: ${action.slug}`,
+    `sourceBytes: ${action.sourceBytes}`,
+    MANAGED_RULE_END,
+  ].join("\n");
+  const body = action.sourceContent.endsWith("\n")
+    ? action.sourceContent
+    : `${action.sourceContent}\n`;
+
+  return `${metadata}\n---\n${frontmatter}\n---\n${body}`;
+}
+
+export function parseManagedRule(text: string): ParsedManagedRule {
+  if (!text.startsWith(MANAGED_RULE_HEADER)) {
+    return { status: "unmanaged", managed: false };
+  }
+
+  const headerEnd = text.indexOf(MANAGED_RULE_END, MANAGED_RULE_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 = parseMetadata(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),
+  };
+}
+
+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)}`;
+  }
+
+  const description = action.description ?? deriveRuleDescription(action.sourceContent) ?? `Use ${action.sourceName} when relevant.`;
+  return `description: ${frontmatterScalarLiteral(description)}`;
+}
+
+export function deriveRuleDescription(sourceContent: string): string | null {
+  for (const rawLine of sourceContent.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("#")) continue;
+    if (line.startsWith("<!--")) continue;
+    return line;
+  }
+  return null;
+}
+
+/**
+ * Encode a frontmatter scalar value.
+ *
+ * The managed rule file uses YAML-shaped frontmatter (`---`-delimited blocks) but the
+ * scalar values are intentionally restricted to JSON string literals: `JSON.stringify`
+ * produces a deterministic, dependency-free encoding that handles quotes, backslashes,
+ * and newlines unambiguously. Parsing uses `JSON.parse` to round-trip the same subset.
+ *
+ * This is a deliberate, narrow subset of YAML — single-quoted strings, multi-line
+ * scalars, anchors, and other YAML constructs are NOT supported. If broader YAML
+ * support becomes necessary, replace both this helper and `parseFrontmatterScalar`
+ * with a real YAML library and update callers accordingly.
+ */
+function frontmatterScalarLiteral(value: string): string {
+  return JSON.stringify(value);
+}
+
+function parseMetadata(headerText: string): ManagedRuleMetadata | string {
+  const lines = headerText.split(/\r?\n/);
+  if (lines[0] !== MANAGED_RULE_HEADER) {
+    return "managed 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", "mode", "sourceId", "sourceName", "sourceHash", "slug", "sourceBytes"];
+  for (const key of required) {
+    if (!raw[key]) return `managed metadata missing ${key}`;
+  }
+
+  if (raw.mode !== "ttsr" && raw.mode !== "rulebook") {
+    return `managed metadata has invalid mode ${raw.mode}`;
+  }
+
+  const version = Number(raw.version);
+  const sourceBytes = Number(raw.sourceBytes);
+  if (!Number.isInteger(version) || version <= 0) return "managed metadata has invalid version";
+  if (!Number.isInteger(sourceBytes) || sourceBytes < 0) return "managed metadata has invalid sourceBytes";
+
+  return {
+    version,
+    mode: raw.mode,
+    sourceId: raw.sourceId,
+    sourceName: raw.sourceName,
+    sourceHash: raw.sourceHash,
+    slug: raw.slug,
+    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";
+  }
+
+  const normalizedStartLength = text.startsWith("---\r\n") ? 5 : 4;
+  const rest = text.slice(normalizedStartLength);
+  const closeMatch = rest.match(/\r?\n---\r?\n/);
+  if (!closeMatch || closeMatch.index === undefined) {
+    return "managed frontmatter is missing closing delimiter";
+  }
+
+  const frontmatterText = rest.slice(0, closeMatch.index);
+  const body = rest.slice(closeMatch.index + closeMatch[0].length);
+  const frontmatter: Record<string, string> = {};
+
+  for (const rawLine of frontmatterText.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const idx = line.indexOf(":");
+    if (idx === -1) return `managed frontmatter has invalid line: ${line}`;
+    const key = line.slice(0, idx).trim();
+    const rawValue = line.slice(idx + 1).trim();
+    const parsedValue = parseFrontmatterScalar(rawValue);
+    if (typeof parsedValue !== "string") {
+      return `managed frontmatter has invalid ${key}`;
+    }
+    frontmatter[key] = parsedValue;
+  }
+
+  return { frontmatter, body };
+}
+
+/**
+ * Decode a frontmatter scalar value.
+ *
+ * See `frontmatterScalarLiteral`: managed rule frontmatter encodes scalars as JSON
+ * string literals. Double-quoted values must round-trip through `JSON.parse`; bare
+ * values (no leading quote) are returned verbatim for forward compatibility with
+ * unquoted single-token scalars.
+ */
+function parseFrontmatterScalar(rawValue: string): string | null {
+  if (!rawValue.startsWith('"')) return rawValue;
+  try {
+    const parsed = JSON.parse(rawValue);
+    return typeof parsed === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function stripTrailingNewline(value: string): string {
+  if (value.endsWith("\r\n")) return value.slice(0, -2);
+  if (value.endsWith("\n")) return value.slice(0, -1);
+  return value;
+}