flavor-code 1.2.11 → 1.2.13

package/dist/astgraph/vendor/zod/v4/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/dist/{chunk-EY6KE7L2.js → chunk-G6Q2Y2A7.js}

@@ -4,7 +4,7 @@ import {
   message,
   redactErrorText,
   redactSecrets
-} from "./chunk-OT5XIN6G.js";
+} from "./chunk-Y5MZDG7I.js";
 
 // src/rpc/server.ts
 import { createInterface } from "readline";

package/dist/{chunk-OT5XIN6G.js → chunk-Y5MZDG7I.js}

@@ -152,11 +152,12 @@ var PermissionEngine = class {
       }
     }
     const inside = paths.every((path) => classifyPath(this.#lexicalWorkspace, this.#workspace, path).inside);
+    const isRead = READ_TOOLS.has(request.tool) || request.readOnly === true;
     if (this.#profile === "d2c") return this.#d2cDecision(request, inside);
     if (this.#mode === "plan") {
-      return READ_TOOLS.has(request.tool) ? { decision: "allow" } : { decision: "deny", reason: "Plan mode is read-only" };
+      return isRead ? { decision: "allow" } : { decision: "deny", reason: "Plan mode is read-only" };
     }
-    if (READ_TOOLS.has(request.tool)) {
+    if (isRead) {
       return { decision: "allow" };
     }
     if (DESTRUCTIVE_TOOLS.has(request.tool)) {
@@ -179,7 +180,7 @@ var PermissionEngine = class {
     if ((request.paths?.length ?? 0) > 0 && !inside) {
       return { decision: "deny", reason: "D2C tools must remain in the workspace" };
     }
-    if (READ_TOOLS.has(request.tool)) return { decision: "allow" };
+    if (READ_TOOLS.has(request.tool) || request.readOnly === true) return { decision: "allow" };
     if (isDeletionTool(request.tool)) {
       return { decision: "ask", reason: "Deletion requires approval", allowAlways: false };
     }
@@ -504,7 +505,7 @@ function redactSecrets(input, secrets) {
 
 // src/init/project.ts
 import { lstat, mkdir, readdir, readFile, realpath, writeFile } from "fs/promises";
-import { readFileSync } from "fs";
+import { copyFileSync, mkdirSync, readdirSync, readFileSync } from "fs";
 import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join, relative as relative2, sep as sep2 } from "path";
 import { fileURLToPath } from "url";
 var GENERATED_START = "<!-- flavor-code:start -->";
@@ -769,6 +770,7 @@ async function inspectProject(cwd) {
     languages.add("Python");
   }
   const gitignorePath = await pathKind(join(cwd, ".gitignore"), root) === "file" ? ".gitignore" : void 0;
+  const hasCodeGraph = await pathKind(join(cwd, ".flavor", "astgraph", "index.db"), root) === "file";
   return {
     cwd,
     projectName,
@@ -784,6 +786,7 @@ async function inspectProject(cwd) {
     instructionFiles,
     configFiles,
     ...gitignorePath === void 0 ? {} : { gitignorePath },
+    hasCodeGraph,
     cautions
   };
 }
@@ -804,6 +807,12 @@ function renderGeneratedSection(facts, newline) {
     "Do not inspect dependency directories or generated output unless explicitly required.",
     ...facts.cautions
   ];
+  const searchSection = facts.hasCodeGraph ? [
+    "",
+    "## Search",
+    "",
+    "- A code graph index is available (`.flavor/astgraph/index.db`): pair `ast_search` with `grep`/`glob` to locate symbols, and use `ast_callers`/`ast_callees`/`ast_impact`/`ast_context` to trace reachability instead of reading files broadly."
+  ] : [];
   return [
     GENERATED_START,
     "## Overview",
@@ -815,6 +824,7 @@ function renderGeneratedSection(facts, newline) {
     "## Layout",
     "",
     bulletList(facts.sourceDirectories, "No conventional source directories detected.", true, newline),
+    ...searchSection,
     "",
     "## Build",
     "",
@@ -964,9 +974,30 @@ async function copyCodeIslandPlugin(cwd) {
     await writeFile(join(pluginDir, name), content);
   }
 }
+var ASTGRAPH_SRC_DIR = join(dirname2(fileURLToPath(import.meta.url)), "astgraph");
+async function copyAstgraphPlugin(cwd) {
+  const pluginDir = join(cwd, ".flavor", "plugins", "astgraph");
+  try {
+    await lstat(pluginDir);
+    return;
+  } catch (error) {
+    if (!isMissingPathError(error)) throw error;
+  }
+  copyDirectory(ASTGRAPH_SRC_DIR, pluginDir);
+}
+function copyDirectory(from, to) {
+  mkdirSync(to, { recursive: true, mode: 448 });
+  for (const entry2 of readdirSync(from, { withFileTypes: true })) {
+    const source = join(from, entry2.name);
+    const target = join(to, entry2.name);
+    if (entry2.isDirectory()) copyDirectory(source, target);
+    else if (entry2.isFile()) copyFileSync(source, target);
+  }
+}
 async function initializeFlavor(cwd) {
   await ensureFlavorDirectories(cwd);
   await copyCodeIslandPlugin(cwd);
+  await copyAstgraphPlugin(cwd);
   await createExampleFlavorConfig(cwd);
   const facts = await inspectProject(cwd);
   const path = join(cwd, "FLAVOR.md");
@@ -3415,7 +3446,7 @@ var FlavorSession = class {
         } catch {
         }
       }
-      const command = parseSlashCommand(prompt, this.#services.pluginCommands(), skillNames);
+      const command = parseSlashCommand(prompt, this.#services.pluginCommands().map(({ name }) => name), skillNames);
       if (command !== null) await this.#dispatch(command, controller.signal);
       else for await (const event of this.#services.run(prompt, controller.signal, {
         getSteeringMessages: () => this.#drainMessages("steer").map((item) => item.text),
@@ -6148,6 +6179,7 @@ function withStructuredOutput(options) {
   }
   const tool = modelToolFromZod(options.name, options.description, options.schema);
   const maxAttempts = retry.maxRetries + 1;
+  const jsonSchema = tool.inputSchema;
   const model = {
     async *stream(request) {
       let candidate;
@@ -6181,6 +6213,7 @@ function withStructuredOutput(options) {
         candidate = void 0;
         rawCandidate = void 0;
         let candidateCount = 0;
+        let textCandidate = "";
         let attemptError;
         let usage;
         for await (const event of adapter.stream(modelRequest)) {
@@ -6198,6 +6231,8 @@ function withStructuredOutput(options) {
             rawCandidate = event.rawInput;
             secrets.add(event.rawInput);
             attemptError = event.error;
+          } else if (event.type === "text") {
+            textCandidate += event.text;
           } else if (event.type === "usage") {
             usage = { inputTokens: event.inputTokens, outputTokens: event.outputTokens };
           } else if (event.type === "done") {
@@ -6208,6 +6243,17 @@ function withStructuredOutput(options) {
         }
         if (usage !== void 0) yield { type: "usage", ...usage };
         if (attemptError === void 0) {
+          if (candidateCount === 0 && textCandidate.trim() !== "") {
+            const extracted = extractJsonObject(textCandidate);
+            if (extracted !== void 0) {
+              candidate = extracted;
+              candidateCount = 1;
+              rawCandidate = textCandidate;
+            }
+          }
+          if (candidateCount === 1 && candidate !== null && typeof candidate === "object") {
+            candidate = coerceByJsonSchema(candidate, jsonSchema);
+          }
           if (candidateCount !== 1) {
             attemptError = {
               code: "invalid_tool_arguments",
@@ -6280,6 +6326,86 @@ function withStructuredOutput(options) {
 function strictJsonSchema(schema) {
   return ensureStrictSchema(z7.toJSONSchema(schema));
 }
+function extractJsonObject(text) {
+  const trimmed = text.trim();
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/u);
+  const candidates = fenced !== null && fenced[1] !== void 0 ? [fenced[1].trim(), trimmed] : [trimmed];
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed !== null && typeof parsed === "object") return parsed;
+    } catch {
+    }
+  }
+  const start = trimmed.indexOf("{");
+  if (start >= 0) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < trimmed.length; index += 1) {
+      const char = trimmed[index];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (char === "\\") escaped = true;
+        else if (char === '"') inString = false;
+        continue;
+      }
+      if (char === '"') inString = true;
+      else if (char === "{") depth += 1;
+      else if (char === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          try {
+            const parsed = JSON.parse(trimmed.slice(start, index + 1));
+            if (parsed !== null && typeof parsed === "object") return parsed;
+          } catch {
+            return void 0;
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function coerceByJsonSchema(value, schema) {
+  if (schema === null || schema === void 0 || typeof schema !== "object") return value;
+  const node = schema;
+  const branches = [
+    ...Array.isArray(node.anyOf) ? node.anyOf : [],
+    ...Array.isArray(node.allOf) ? node.allOf : []
+  ].filter((branch) => branch !== null && typeof branch === "object");
+  const types = [];
+  const pushTypes = (candidate) => {
+    if (typeof candidate.type === "string") types.push(candidate.type);
+    else if (Array.isArray(candidate.type)) types.push(...candidate.type);
+  };
+  pushTypes(node);
+  for (const branch of branches) pushTypes(branch);
+  if (types.includes("null") && (value === null || value === void 0)) return value;
+  if ((types.includes("number") || types.includes("integer")) && typeof value === "string" && value.trim() !== "") {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+  }
+  if (types.includes("boolean") && typeof value === "string") {
+    const lowered = value.trim().toLowerCase();
+    if (lowered === "true") return true;
+    if (lowered === "false") return false;
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const properties = node.properties ?? branches.find((branch) => branch.properties)?.properties;
+    if (properties !== void 0) {
+      const output = {};
+      for (const [key, child] of Object.entries(value)) {
+        output[key] = properties[key] !== void 0 ? coerceByJsonSchema(child, properties[key]) : child;
+      }
+      return output;
+    }
+  }
+  if (types.includes("array") && Array.isArray(value) && node.items !== void 0) {
+    return value.map((item) => coerceByJsonSchema(item, node.items));
+  }
+  return value;
+}
 function modelToolFromZod(name, description, schema) {
   return { name, description, inputSchema: strictJsonSchema(schema) };
 }
@@ -6642,6 +6768,14 @@ var AgentLoop = class {
           toolCalls.push({ id: collected.id, name: collected.name, input: validation.input });
           continue;
         }
+        if (collected.kind === "valid") {
+          const coerced = coerceByJsonSchema(collected.input, strictJsonSchema(definition.inputSchema));
+          const revalidation = this.#options.runtime.validate({ ...collected, input: coerced });
+          if (revalidation.ok) {
+            toolCalls.push({ id: collected.id, name: collected.name, input: revalidation.input });
+            continue;
+          }
+        }
         const repairModelId = this.#options.fallbackModelId ?? this.#options.modelId;
         const invalidOutput = collected.kind === "invalid" ? collected.rawInput : serializeToolInput(collected.input);
         const structured = withStructuredOutput({
@@ -7141,7 +7275,8 @@ var ToolRuntime = class {
       const request = {
         agent: context.agent,
         tool: tool.name,
-        ...tool.permissions?.(input) ?? { paths: tool.paths(input) }
+        ...tool.permissions?.(input) ?? { paths: tool.paths(input) },
+        ...tool.readOnly === true ? { readOnly: true } : {}
       };
       let permission = this.#permissions.decide(request);
       const nonCacheableApproval = request.allowAlways === false || permission.allowAlways === false;
@@ -9214,7 +9349,9 @@ var ShellInput = z14.object({
   args: z14.array(z14.string()),
   cwd: z14.string().min(1).nullable().optional(),
   timeoutMs: z14.coerce.number().int().positive().max(864e5).nullable().optional(),
-  background: z14.boolean().optional()
+  // Accepts booleans and their string forms (weak-typed models emit "true");
+  // kept transform-free so the schema converts to JSON Schema for providers.
+  background: z14.union([z14.boolean(), z14.string().refine((value) => value === "true" || value === "false")]).optional()
 });
 function createShellTool(workspace, options = {}) {
   const root = resolve11(workspace);
@@ -9230,7 +9367,7 @@ function createShellTool(workspace, options = {}) {
     inputSchema: ShellInput,
     paths: (input) => [workingDirectory(root, input.cwd ?? void 0)],
     summarize: (input) => [input.command, ...input.args].join(" "),
-    presentCall: (input) => ({ kind: "terminal", variant: "command", title: input.background ? "Starting background command" : "Running command", command: [input.command, ...input.args].join(" "), state: "running" }),
+    presentCall: (input) => ({ kind: "terminal", variant: "command", title: backgroundFlag(input.background) ? "Starting background command" : "Running command", command: [input.command, ...input.args].join(" "), state: "running" }),
     permissions: (input) => ({
       paths: [workingDirectory(root, input.cwd ?? void 0)],
       command: input.command,
@@ -9247,7 +9384,7 @@ function createShellTool(workspace, options = {}) {
     } : { kind: "terminal", variant: "command", title: [input.command, ...input.args].join(" "), command: [input.command, ...input.args].join(" "), stdout: output.stdout, stderr: output.stderr, exitCode: output.exitCode, state: output.terminationReason === "cancelled" ? "cancelled" : output.exitCode === 0 ? "completed" : "failed", truncated: output.truncated },
     execute: async (input, signal, context) => {
       const timeoutMs = input.timeoutMs ?? defaultTimeoutMs;
-      if (input.background === true) {
+      if (backgroundFlag(input.background)) {
         if (options.jobs === void 0) throw new Error("Background shell requires a JobRegistry");
         const cancellation = new AbortController();
         const job = options.jobs.create({
@@ -9497,6 +9634,9 @@ var AdaptiveOutputDecoder = class {
     return text;
   }
 };
+function backgroundFlag(value) {
+  return value === true || value === "true";
+}
 function workingDirectory(root, cwd = ".") {
   const candidate = resolve11(root, cwd);
   const delta = relative10(root, candidate);
@@ -11325,7 +11465,7 @@ var PluginHost = class {
           return writeFile6(allowed, data2);
         }
       }) }),
-      registerCommand: (name, value) => register("command", name, [value]),
+      registerCommand: (name, value, description) => register("command", name, [value, description]),
       registerTool: (name, value) => register("tool", name, [value]),
       registerHook: (name, value, options) => register("hook", name, [value, options]),
       registerSkillRoot: (name, root) => {
@@ -16925,7 +17065,8 @@ import { z as z27 } from "zod";
 import { resolve as resolve23 } from "path";
 var Id = z27.string().regex(/^term-[a-f0-9-]+$/);
 var OpenInput = z27.object({ cwd: z27.string().optional(), shell: z27.string().optional(), args: z27.array(z27.string()).optional(), columns: z27.coerce.number().int().min(10).max(500).optional(), rows: z27.coerce.number().int().min(2).max(300).optional() });
-var WriteInput2 = z27.object({ id: Id, data: z27.string().max(1e5), enter: z27.boolean().optional() });
+var OptionalBoolean = z27.union([z27.boolean(), z27.string().refine((value) => value === "true" || value === "false")]);
+var WriteInput2 = z27.object({ id: Id, data: z27.string().max(1e5), enter: OptionalBoolean.optional() });
 var ReadInput3 = z27.object({ id: Id, cursor: z27.coerce.number().int().min(0).optional() });
 var ResizeInput = z27.object({ id: Id, columns: z27.coerce.number().int().min(10).max(500), rows: z27.coerce.number().int().min(2).max(300) });
 var CloseInput = z27.object({ id: Id });
@@ -16954,8 +17095,9 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
       paths: () => [],
       permissions: (input) => ({ paths: [], command: input.data, args: [] }),
       execute: async (input, _signal, context) => {
-        terminals.write(input.id, owner(context), input.data + (input.enter ? "\r" : ""));
-        return { id: input.id, written: input.data.length + (input.enter ? 1 : 0) };
+        const enter = input.enter === true || input.enter === "true";
+        terminals.write(input.id, owner(context), input.data + (enter ? "\r" : ""));
+        return { id: input.id, written: input.data.length + (enter ? 1 : 0) };
       }
     },
     {
@@ -17832,15 +17974,16 @@ async function createProductionRuntime(options) {
     projectPluginDirs: [join19(workspace, ".flavor", "plugins")],
     config,
     registrations: {
-      command(name, handler) {
+      command(name, handler, description) {
         if (typeof handler !== "function") throw new Error(`Plugin command "${name}" must be a function.`);
         if (name !== name.toLowerCase()) throw new Error(`Plugin command "${name}" must be lowercase.`);
         if (MVP_COMMANDS.includes(name) || name === "ide" || pluginCommands.has(name)) {
           throw new Error(`Plugin command "${name}" conflicts with a built-in or registered command.`);
         }
-        pluginCommands.set(name, handler);
+        const desc = typeof description === "string" && description.trim().length > 0 ? description.trim() : void 0;
+        pluginCommands.set(name, desc === void 0 ? { handler } : { handler, description: desc });
         return () => {
-          if (pluginCommands.get(name) === handler) pluginCommands.delete(name);
+          if (pluginCommands.get(name)?.handler === handler) pluginCommands.delete(name);
         };
       },
       tool(name, tool) {
@@ -18937,9 +19080,9 @@ ${renderMemoryDocument(entries)}`;
         return removed === 0 ? "No cold long-term memories to remove." : `Forgot ${removed} cold memory ${removed === 1 ? "entry" : "entries"} and removed ${filesRemoved} task ${filesRemoved === 1 ? "file" : "files"}.`;
       },
       finishTask: () => finalizeMemoryTask(true),
-      pluginCommands: () => [...pluginCommands.keys()].sort(),
+      pluginCommands: () => [...pluginCommands.entries()].map(([name, entry2]) => entry2.description === void 0 ? { name } : { name, description: entry2.description }).sort((left, right) => left.name.localeCompare(right.name)),
       runPluginCommand: async (name, args, signal) => {
-        const handler = pluginCommands.get(name);
+        const handler = pluginCommands.get(name)?.handler;
         if (handler === void 0) throw new Error(`Plugin command /${name} is no longer registered.`);
         signal.throwIfAborted();
         return awaitWithSignal(Promise.resolve(handler(args, { workspace, signal })), signal);

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-EY6KE7L2.js";
+} from "./chunk-G6Q2Y2A7.js";
 import {
   staticTaskLines
 } from "./chunk-KKIBYDJI.js";
@@ -22,7 +22,7 @@ import {
   packageVersion,
   redactErrorText,
   runPalBroker
-} from "./chunk-OT5XIN6G.js";
+} from "./chunk-Y5MZDG7I.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -800,7 +800,7 @@ async function runInteractiveCli(props) {
   const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
     import("./claude-ink-ORUA7GWG.js"),
     import("react"),
-    import("./app-MXWPZBEU.js")
+    import("./app-Z3YWFIBB.js")
   ]);
   const instance = await render(createElement(
     AlternateScreen,