flavor-code 1.4.2 → 1.4.3

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
 import {
   MEMORY_RESTART_EXIT_CODE,
   memoryRestartArgs,
   memoryRestartMarkerPath,
   parseMemoryRestartMarker
-} from "./chunk-N5MXHJKD.js";
-import "./chunk-S32JRDZK.js";
+} from "./chunk-GTFP2R5I.js";
+import "./chunk-ZKKVSR37.js";
 
 // src/launcher.ts
 import { spawn } from "child_process";
@@ -20,6 +20,50 @@ function needsRelaunch(runtime) {
   if (!runtime.execArgv.some((argument) => argument === "--heap-prof")) return true;
   return !runtime.execArgv.some((argument) => argument === "--expose-gc");
 }
+var LIGHT_CLI_COMMANDS = /* @__PURE__ */ new Set([
+  "init",
+  "update",
+  "doctor",
+  "skills",
+  "memory",
+  "mcp",
+  "sessions",
+  "config",
+  "usage",
+  "eval",
+  "help",
+  "completion"
+]);
+function isLightCommand(argv) {
+  for (const argument of argv) {
+    if (argument === "--") break;
+    if (argument.startsWith("-") && argument !== "-") {
+      if (argument === "--pals-broker" || argument.startsWith("--pals-broker=")) return false;
+      if (/^-(?:[vh]|.*version\b|.*help\b)/u.test(argument)) return true;
+      continue;
+    }
+    return LIGHT_CLI_COMMANDS.has(argument);
+  }
+  return false;
+}
+var OUTPUT_FORMAT_VALUES = /* @__PURE__ */ new Set(["text", "json", "stream-json"]);
+var PERMISSION_MODE_VALUES = /* @__PURE__ */ new Set(["default", "plan", "acceptEdits", "bypassPermissions"]);
+function isStaticUsageError(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    const value = (flag, allowed) => {
+      if (argument === flag) {
+        const next = argv[index + 1];
+        return next !== void 0 && !next.startsWith("-") && !allowed.has(next);
+      }
+      if (argument?.startsWith(`${flag}=`)) return !allowed.has(argument.slice(flag.length + 1));
+      return void 0;
+    };
+    if (value("--output-format", OUTPUT_FORMAT_VALUES) === true) return true;
+    if (value("--permission-mode", PERMISSION_MODE_VALUES) === true) return true;
+  }
+  return false;
+}
 var HEAP_HEADROOM_MB = 8192;
 var HEAP_HEADROOM_MIN_TOTALMEM = 12 * 1024 * 1024 * 1024;
 function cliMainArguments(mainPath, argv, heapProfile) {
@@ -66,7 +110,7 @@ async function launchCli() {
   const runtime = {
     execArgv: process.execArgv
   };
-  if (!needsRelaunch(runtime)) {
+  if (isLightCommand(process.argv.slice(2)) || isStaticUsageError(process.argv.slice(2)) || !needsRelaunch(runtime)) {
     const cli = await import(mainUrl.href);
     await cli.runCli(process.argv);
     return;
@@ -141,6 +185,8 @@ if (process.argv[1]) {
 }
 export {
   cliMainArguments,
+  isLightCommand,
+  isStaticUsageError,
   launchCli,
   needsRelaunch
 };

package/dist/config/load.d.ts

@@ -17,5 +17,13 @@ export declare function setProjectMcpServerDisabled(cwd: string, serverName: str
 export declare function setProjectSkillDisabled(cwd: string, skillName: string, disabled: boolean, inheritedDisabled?: readonly string[]): Promise<string>;
 export declare function setGlobalProviderConfig(home: string, providerName: string, provider: ProviderConfig): Promise<string>;
 export declare function setProjectProviderConfig(cwd: string, providerName: string, provider: ProviderConfig): Promise<string>;
+/**
+ * Write one value into the project `.flavor/flavor.json`. The merged result is
+ * validated through `loadConfig` before any write, so an invalid value aborts
+ * the update and leaves the file untouched (backups included).
+ */
+export declare function setProjectConfigValue(cwd: string, home: string, key: string, value: unknown): Promise<string>;
+/** Remove one key from the project `.flavor/flavor.json`, falling back to global/default layers. */
+export declare function unsetProjectConfigValue(cwd: string, key: string): Promise<string>;
 export declare function redactConfig(config: unknown): unknown;
 export {};

package/dist/config/protected-file.d.ts

@@ -19,3 +19,5 @@ export interface ProtectedFileOperations {
 }
 export declare function readRecoverableFile<T>(path: string, decode: (raw: string) => T | Promise<T>): Promise<RecoverableFile<T> | undefined>;
 export declare function updateProtectedFile<T>(options: ProtectedFileUpdate<T>): Promise<T>;
+/** Lock and atomically update user-authored text without backup recovery or rewriting unchanged content. */
+export declare function updatePlainTextFile(path: string, update: (current: string | undefined) => string | undefined | Promise<string | undefined>, maxBytes?: number): Promise<string | undefined>;

package/dist/config/schema.d.ts

@@ -20,6 +20,10 @@ export declare const ProviderConfigSchema: z.ZodObject<{
     models: z.ZodOptional<z.ZodArray<z.ZodString>>;
     maxOutputTokens: z.ZodOptional<z.ZodNumber>;
     thinkingBudget: z.ZodOptional<z.ZodNumber>;
+    cacheTtl: z.ZodOptional<z.ZodEnum<{
+        "1h": "1h";
+        "5m": "5m";
+    }>>;
     thinkingEffort: z.ZodOptional<z.ZodEnum<{
         high: "high";
         low: "low";
@@ -78,6 +82,10 @@ export declare const FlavorConfigSchema: z.ZodObject<{
         models: z.ZodOptional<z.ZodArray<z.ZodString>>;
         maxOutputTokens: z.ZodOptional<z.ZodNumber>;
         thinkingBudget: z.ZodOptional<z.ZodNumber>;
+        cacheTtl: z.ZodOptional<z.ZodEnum<{
+            "1h": "1h";
+            "5m": "5m";
+        }>>;
         thinkingEffort: z.ZodOptional<z.ZodEnum<{
             high: "high";
             low: "low";
@@ -112,6 +120,9 @@ export declare const FlavorConfigSchema: z.ZodObject<{
     skills: z.ZodPrefault<z.ZodObject<{
         disabled: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
+    globalInstructions: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
     agents: z.ZodOptional<z.ZodObject<{
         main: z.ZodOptional<z.ZodObject<{
             model: z.ZodString;
@@ -204,3 +215,6 @@ export type McpServerConfig = z.infer<typeof McpServerConfigSchema>;
 export type McpServerConfigInput = z.input<typeof McpServerConfigSchema>;
 export type McpStdioServerConfig = z.infer<typeof McpStdioServerConfigSchema>;
 export type McpHttpServerConfig = z.infer<typeof McpHttpServerConfigSchema>;
+/** Top-level configuration keys, used to reject typos in `flavor config set/get`. */
+export declare const CONFIG_TOP_LEVEL_KEYS: string[];
+export declare function configPathSegments(key: string): string[];

package/dist/context/global-instructions.d.ts

@@ -0,0 +1,12 @@
+/** User-maintained rules; only explicit /global commands write this file. */
+export declare class GlobalInstructions {
+    #private;
+    static readonly MAX_BYTES: number;
+    static readonly MAX_RULE_BYTES: number;
+    readonly path: string;
+    constructor(home: string);
+    get content(): string | undefined;
+    refresh(): Promise<void>;
+    remember(input: string): Promise<"added" | "already-present">;
+    forget(input: string): Promise<"removed" | "not-found" | "ambiguous">;
+}

package/dist/context/manager.d.ts

@@ -12,6 +12,8 @@ export interface ContextManagerOptions {
     taskState?: string;
     /** Stable user preferences, emitted as the final system section for prompt caching. */
     userMemory?: SystemPromptSource;
+    /** User-authored global rules, placed after the stable cache breakpoint. */
+    globalInstructions?: SystemPromptSource;
     /** @deprecated Prefer token-based compaction policy. */
     compactAtChars?: number;
     toolOutputChars: number;
@@ -51,6 +53,8 @@ export interface ContextEpochSnapshot {
     stableMessages: ContextSystemMessage[];
     /** Last admitted values for dynamic sources. */
     sources: Record<string, string>;
+    /** Immutable dynamic-source snapshot rendered before conversation history. */
+    pinnedSources?: Record<string, string> | undefined;
     stableSourceHash: string;
 }
 export interface ContextSystemMessage {