flavor-code 1.4.1 → 1.4.3-beta.2

package/dist/chunk-KRWWCVXA.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+
+// src/utils/log.ts
+import { appendFile, mkdir } from "fs/promises";
+import { dirname, join, resolve } from "path";
+var pending = Promise.resolve();
+var usagePending = Promise.resolve();
+function logError(error) {
+  if (process.env.DEBUG) process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
+`);
+}
+function usageLogPath() {
+  return process.env.FLAVOR_USAGE_FILE ?? join(process.cwd(), ".flavor", "usage.jsonl");
+}
+var usageSessionId = "unknown";
+var truncateOnNextAppend = false;
+function setUsageSession(sessionId) {
+  usageSessionId = sessionId;
+  truncateOnNextAppend = true;
+}
+function currentUsageSession() {
+  return usageSessionId;
+}
+async function appendUsageLog(line) {
+  usagePending = usagePending.catch(() => void 0).then(async () => {
+    try {
+      const path = usageLogPath();
+      await mkdir(dirname(path), { recursive: true, mode: 448 });
+      const flag = truncateOnNextAppend ? "w" : "a";
+      truncateOnNextAppend = false;
+      await appendFile(path, `${line}
+`, { encoding: "utf8", mode: 384, flag });
+    } catch {
+    }
+  });
+  return usagePending;
+}
+var AuditLogger = class {
+  #path;
+  #closed = false;
+  constructor(workspace) {
+    this.#path = join(resolve(workspace), ".flavor", "audit.jsonl");
+  }
+  get path() {
+    return this.#path;
+  }
+  async append(entry) {
+    if (this.#closed) return;
+    const line = `${JSON.stringify(entry)}
+`;
+    pending = pending.catch(() => void 0).then(() => this.#write(line));
+    return pending;
+  }
+  async #write(line) {
+    try {
+      await mkdir(dirname(this.#path), { recursive: true, mode: 448 });
+      await appendFile(this.#path, line, { encoding: "utf8", mode: 384, flag: "a" });
+    } catch {
+    }
+  }
+  close() {
+    this.#closed = true;
+  }
+};
+
+export {
+  logError,
+  usageLogPath,
+  setUsageSession,
+  currentUsageSession,
+  appendUsageLog,
+  AuditLogger
+};

package/dist/chunk-OKHV7CTB.js

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+
+// src/init/project.ts
+import { lstat, mkdir, readdir, readFile, realpath, writeFile } from "fs/promises";
+import { basename, isAbsolute, join, relative, sep } from "path";
+var GENERATED_START = "<!-- flavor-code:start -->";
+var GENERATED_END = "<!-- flavor-code:end -->";
+var MAX_MANIFEST_BYTES = 1e6;
+var JAVASCRIPT_LOCKFILES = [
+  { name: "package-lock.json", manager: "npm" },
+  { name: "npm-shrinkwrap.json", manager: "npm" },
+  { name: "pnpm-lock.yaml", manager: "pnpm" },
+  { name: "yarn.lock", manager: "yarn" },
+  { name: "bun.lock", manager: "bun" },
+  { name: "bun.lockb", manager: "bun" }
+];
+var SOURCE_DIRECTORIES = [
+  "src",
+  "app",
+  "lib",
+  "packages",
+  "tests",
+  "test",
+  "spec"
+];
+var INSTRUCTION_FILES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  "GEMINI.md",
+  ".github/copilot-instructions.md"
+];
+var CONFIG_FILES = [
+  "tsconfig.json",
+  "jsconfig.json",
+  "vitest.config.ts",
+  "vitest.config.js",
+  "jest.config.ts",
+  "jest.config.js",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  ".eslintrc",
+  ".eslintrc.json",
+  "biome.json",
+  "prettier.config.js",
+  ".prettierrc",
+  "pytest.ini",
+  "tox.ini",
+  ".ruff.toml",
+  "ruff.toml",
+  "mypy.ini"
+];
+function isContainedPath(root, candidate) {
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`) && !isAbsolute(pathFromRoot);
+}
+async function pathKind(path, root) {
+  try {
+    const details = await lstat(path);
+    if (details.isSymbolicLink() || !isContainedPath(root, await realpath(path))) return void 0;
+    if (details.isFile()) return "file";
+    if (details.isDirectory()) return "directory";
+    return void 0;
+  } catch (error) {
+    if (isMissingPathError(error)) return void 0;
+    throw error;
+  }
+}
+function isMissingPathError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function readTextIfSmall(path, root) {
+  const details = await lstat(path).catch((error) => {
+    if (isMissingPathError(error)) return void 0;
+    throw error;
+  });
+  if (details === void 0 || !details.isFile() || details.isSymbolicLink() || details.size > MAX_MANIFEST_BYTES || !isContainedPath(root, await realpath(path))) {
+    return void 0;
+  }
+  return readFile(path, "utf8");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitizeProjectName(value) {
+  const sanitized = value.replace(/<!--/g, "").replace(/-->/g, "").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
+  return sanitized === "" ? void 0 : sanitized;
+}
+function joinWithAnd(values) {
+  if (values.length < 2) return values[0] ?? "";
+  return `${values.slice(0, -1).join(", ")} and ${values.at(-1)}`;
+}
+function packageCommand(manager, script) {
+  if (manager === "npm") {
+    return script === "test" ? "npm test" : `npm run ${script}`;
+  }
+  if (manager === "yarn") return `yarn ${script}`;
+  if (manager === "bun") return `bun run ${script}`;
+  return `${manager} ${script}`;
+}
+function addScriptCommand(target, scripts, manager, names) {
+  if (manager === void 0) return;
+  const script = names.find((name) => scripts[name] !== void 0);
+  if (script !== void 0) target.push(packageCommand(manager, script));
+}
+function detectPythonTools(pyproject, requirements, configFiles) {
+  const tools = /* @__PURE__ */ new Set();
+  const sections = pyproject?.matchAll(/^\s*\[tool\.([A-Za-z0-9_-]+)(?:\.|\])/gm) ?? [];
+  for (const match of sections) {
+    const tool = match[1];
+    if (tool !== void 0) tools.add(tool.toLowerCase());
+  }
+  if (configFiles.includes("pytest.ini")) tools.add("pytest");
+  if (configFiles.includes("ruff.toml") || configFiles.includes(".ruff.toml")) tools.add("ruff");
+  for (const line of requirements?.split(/\r?\n/) ?? []) {
+    const match = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/.exec(line);
+    if (match?.[1] !== void 0 && !line.trimStart().startsWith("#")) {
+      tools.add(match[1].toLowerCase().replace(/[-_.]+/g, "-"));
+    }
+  }
+  return tools;
+}
+async function sampleSourceExtensions(cwd, root, directories) {
+  const extensions = /* @__PURE__ */ new Set();
+  const sampleDirectories = ["", ...directories].slice(0, 12);
+  for (const relativeDirectory of sampleDirectories) {
+    const absoluteDirectory = join(cwd, relativeDirectory);
+    if (!isContainedPath(root, await realpath(absoluteDirectory))) continue;
+    let entries;
+    try {
+      entries = await readdir(absoluteDirectory, { withFileTypes: true });
+    } catch (error) {
+      if (isMissingPathError(error)) continue;
+      throw error;
+    }
+    for (const entry of entries.slice(0, 200)) {
+      if (!entry.isFile()) continue;
+      const match = /\.([A-Za-z0-9]+)$/.exec(entry.name);
+      if (match?.[1] !== void 0) extensions.add(match[1].toLowerCase());
+    }
+  }
+  return extensions;
+}
+async function inspectProject(cwd) {
+  const root = await realpath(cwd);
+  const sourceDirectories = [];
+  for (const directory of SOURCE_DIRECTORIES) {
+    if (await pathKind(join(cwd, directory), root) === "directory") sourceDirectories.push(directory);
+  }
+  const instructionFiles = [];
+  for (const file of INSTRUCTION_FILES) {
+    if (await pathKind(join(cwd, file), root) === "file") instructionFiles.push(file);
+  }
+  const configFiles = [];
+  for (const file of CONFIG_FILES) {
+    if (await pathKind(join(cwd, file), root) === "file") configFiles.push(file);
+  }
+  const manifestNames = [
+    "package.json",
+    ...JAVASCRIPT_LOCKFILES.map(({ name }) => name),
+    "pyproject.toml",
+    "requirements.txt",
+    "uv.lock",
+    "poetry.lock",
+    "Pipfile"
+  ];
+  const present = /* @__PURE__ */ new Set();
+  for (const manifest of manifestNames) {
+    if (await pathKind(join(cwd, manifest), root) === "file") present.add(manifest);
+  }
+  const detectedLockfiles = JAVASCRIPT_LOCKFILES.filter(({ name }) => present.has(name));
+  const detectedJsManagers = [
+    ...new Set(detectedLockfiles.map(({ manager }) => manager))
+  ];
+  const pythonManagers = [];
+  if (present.has("uv.lock")) {
+    pythonManagers.push("uv");
+  } else if (present.has("poetry.lock")) {
+    pythonManagers.push("poetry");
+  } else if (present.has("Pipfile")) {
+    pythonManagers.push("pipenv");
+  } else if (present.has("pyproject.toml") || present.has("requirements.txt")) {
+    pythonManagers.push("pip");
+  }
+  const cautions = [];
+  if (detectedLockfiles.length > 1) {
+    cautions.push(
+      `Multiple JavaScript lockfiles detected: ${detectedLockfiles.map(({ name }) => name).join(", ")}.`
+    );
+  }
+  const scripts = {};
+  let projectName = sanitizeProjectName(basename(cwd)) ?? "project";
+  let declaredJsManager;
+  if (present.has("package.json")) {
+    const text = await readTextIfSmall(join(cwd, "package.json"), root);
+    if (text === void 0) {
+      cautions.push("package.json was too large to inspect; its scripts were ignored.");
+    } else {
+      try {
+        const parsed = JSON.parse(text);
+        if (!isRecord(parsed)) throw new Error("not an object");
+        const manifest = parsed;
+        if (typeof manifest.name === "string") {
+          projectName = sanitizeProjectName(manifest.name) ?? projectName;
+        }
+        if (typeof manifest.packageManager === "string") {
+          declaredJsManager = /^(npm|pnpm|yarn|bun)@/.exec(manifest.packageManager)?.[1];
+        }
+        if (isRecord(manifest.scripts)) {
+          for (const [name, command] of Object.entries(manifest.scripts).sort(
+            ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+          )) {
+            if (typeof command === "string") scripts[name] = command;
+          }
+        }
+      } catch {
+        cautions.push("package.json could not be parsed; its scripts were ignored.");
+      }
+    }
+  }
+  let selectedJsManager;
+  if (declaredJsManager !== void 0) {
+    selectedJsManager = declaredJsManager;
+    const conflicts = detectedJsManagers.filter((manager) => manager !== declaredJsManager);
+    if (conflicts.length > 0) {
+      cautions.push(
+        `package.json declares ${declaredJsManager}, but lockfiles for ${joinWithAnd(conflicts)} were also detected; using the declaration.`
+      );
+    }
+  } else if (detectedJsManagers.length === 1) {
+    selectedJsManager = detectedJsManagers[0];
+  } else if (detectedJsManagers.length === 0 && present.has("package.json")) {
+    selectedJsManager = "npm";
+  } else if (detectedJsManagers.length > 1) {
+    cautions.push("JavaScript package manager is ambiguous; script commands were omitted.");
+  }
+  const orderedJsManagers = selectedJsManager === void 0 ? detectedJsManagers : [selectedJsManager, ...detectedJsManagers.filter((manager) => manager !== selectedJsManager)];
+  const packageManagers = [...orderedJsManagers, ...pythonManagers];
+  const packageManager = selectedJsManager ?? pythonManagers[0];
+  const jsManager = selectedJsManager;
+  const buildCommands = [];
+  const testCommands = [];
+  const lintCommands = [];
+  const formatCommands = [];
+  addScriptCommand(buildCommands, scripts, jsManager, ["build"]);
+  addScriptCommand(testCommands, scripts, jsManager, ["test"]);
+  addScriptCommand(lintCommands, scripts, jsManager, ["lint"]);
+  addScriptCommand(formatCommands, scripts, jsManager, ["format", "format:check"]);
+  const pyproject = present.has("pyproject.toml") ? await readTextIfSmall(join(cwd, "pyproject.toml"), root) : void 0;
+  const requirements = present.has("requirements.txt") ? await readTextIfSmall(join(cwd, "requirements.txt"), root) : void 0;
+  const pythonTools = detectPythonTools(pyproject, requirements, configFiles);
+  const pythonManager = pythonManagers[0];
+  const pythonPrefix = pythonManager === "uv" ? "uv run " : pythonManager === "poetry" ? "poetry run " : pythonManager === "pipenv" ? "pipenv run " : "";
+  if (pythonTools.has("pytest")) testCommands.push(`${pythonPrefix}pytest`);
+  if (pythonTools.has("ruff")) lintCommands.push(`${pythonPrefix}ruff check .`);
+  if (pythonTools.has("black")) formatCommands.push(`${pythonPrefix}black --check .`);
+  const extensions = await sampleSourceExtensions(cwd, root, sourceDirectories);
+  const languages = /* @__PURE__ */ new Set();
+  const hasTypeScript = configFiles.includes("tsconfig.json") || ["ts", "tsx", "mts", "cts"].some((extension) => extensions.has(extension));
+  if (hasTypeScript) {
+    languages.add("TypeScript");
+  } else if (present.has("package.json") || ["js", "jsx", "mjs", "cjs"].some((extension) => extensions.has(extension))) {
+    languages.add("JavaScript");
+  }
+  if (present.has("pyproject.toml") || present.has("requirements.txt") || extensions.has("py")) {
+    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,
+    languages: [...languages].sort(),
+    ...packageManager === void 0 ? {} : { packageManager },
+    packageManagers,
+    scripts,
+    buildCommands,
+    testCommands,
+    lintCommands,
+    formatCommands,
+    sourceDirectories,
+    instructionFiles,
+    configFiles,
+    ...gitignorePath === void 0 ? {} : { gitignorePath },
+    hasCodeGraph,
+    cautions
+  };
+}
+function bulletList(values, empty, code, newline) {
+  if (values.length === 0) return empty;
+  return values.map((value) => `- ${code ? `\`${value}\`` : value}`).join(newline);
+}
+function renderGeneratedSection(facts, newline) {
+  const languages = facts.languages.length === 0 ? "not detected" : facts.languages.join(", ");
+  const managers = facts.packageManagers.length === 0 ? "not detected" : facts.packageManagers.join(", ");
+  const qualityCommands = [...facts.lintCommands, ...facts.formatCommands];
+  const conventions = [
+    ...facts.instructionFiles.map((file) => `Follow \`${file}\`.`),
+    ...facts.configFiles.map((file) => `Respect \`${file}\`.`)
+  ];
+  const cautions = [
+    "Do not read or copy secrets from environment files.",
+    "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",
+    "",
+    `- Project: ${facts.projectName}`,
+    `- Languages: ${languages}`,
+    `- Package manager: ${managers}`,
+    "",
+    "## Layout",
+    "",
+    bulletList(facts.sourceDirectories, "No conventional source directories detected.", true, newline),
+    ...searchSection,
+    "",
+    "## Build",
+    "",
+    bulletList(facts.buildCommands, "No verified build command detected.", true, newline),
+    "",
+    "## Test",
+    "",
+    bulletList(facts.testCommands, "No verified test command detected.", true, newline),
+    "",
+    "## Quality",
+    "",
+    bulletList(qualityCommands, "No verified lint or format command detected.", true, newline),
+    "",
+    "## Conventions",
+    "",
+    bulletList(conventions, "No additional project instruction or quality configuration files detected.", false, newline),
+    "",
+    "## Cautions",
+    "",
+    bulletList(cautions, "", false, newline),
+    GENERATED_END
+  ].join(newline);
+}
+function detectNewline(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function mergeGeneratedSection(existing, generated) {
+  if (existing === void 0 || existing === "") return `${generated}
+`;
+  const newline = detectNewline(existing);
+  let searchFrom = 0;
+  let lastPair;
+  while (searchFrom < existing.length) {
+    const start = existing.indexOf(GENERATED_START, searchFrom);
+    if (start === -1) break;
+    const end = existing.indexOf(GENERATED_END, start + GENERATED_START.length);
+    if (end === -1) break;
+    lastPair = { start, end };
+    searchFrom = end + GENERATED_END.length;
+  }
+  if (lastPair !== void 0) {
+    return `${existing.slice(0, lastPair.start)}${generated}${existing.slice(lastPair.end + GENERATED_END.length)}`;
+  }
+  const separator = existing.endsWith("\n") ? newline : `${newline}${newline}`;
+  return `${existing}${separator}${generated}${newline}`;
+}
+var GITIGNORE_ENTRIES = [".flavor", "FLAVOR.md"];
+function isEntryIgnored(lines, entry) {
+  return lines.some((line) => {
+    const normalized = line.trim().replace(/^\//, "").replace(/\/$/, "");
+    return normalized === entry;
+  });
+}
+async function addSessionsToGitignore(cwd) {
+  const path = join(cwd, ".gitignore");
+  const root = await realpath(cwd);
+  await assertSafeManagedPath(path, root);
+  let existing;
+  try {
+    existing = await readFile(path, "utf8");
+  } catch (error) {
+    if (!isMissingPathError(error)) throw error;
+    existing = "";
+  }
+  const lines = existing.split(/\r?\n/);
+  const newline = detectNewline(existing);
+  const missing = GITIGNORE_ENTRIES.filter((entry) => !isEntryIgnored(lines, entry));
+  if (missing.length === 0) return;
+  const separator = existing === "" || existing.endsWith("\n") ? "" : newline;
+  const append = missing.map((entry) => entry).join(newline);
+  await writeFile(path, `${existing}${separator}${append}${newline}`);
+}
+async function assertSafeManagedPath(path, root) {
+  try {
+    const details = await lstat(path);
+    if (details.isSymbolicLink()) {
+      throw new Error(`Refusing to overwrite managed file symbolic link: ${path}`);
+    }
+    if (!isContainedPath(root, await realpath(path))) {
+      throw new Error(`Refusing to overwrite managed file outside the project: ${path}`);
+    }
+  } catch (error) {
+    if (isMissingPathError(error)) return;
+    throw error;
+  }
+}
+async function ensureFlavorDirectories(cwd) {
+  const root = await realpath(cwd);
+  const sessionsDir = join(cwd, ".flavor", "sessions");
+  const skillsDir = join(cwd, ".flavor", "skills");
+  const pluginsDir = join(cwd, ".flavor", "plugins");
+  await mkdir(sessionsDir, { recursive: true, mode: 448 });
+  await mkdir(skillsDir, { recursive: true, mode: 448 });
+  await mkdir(pluginsDir, { recursive: true, mode: 448 });
+  const canonicalRoot = await realpath(root);
+  for (const dir of [sessionsDir, skillsDir, pluginsDir]) {
+    const canonical = await realpath(dir);
+    if (!isContainedPath(canonicalRoot, canonical)) {
+      throw new Error(`Directory escapes the workspace: ${dir}`);
+    }
+  }
+}
+async function createExampleFlavorConfig(cwd) {
+  const configPath = join(cwd, ".flavor", "flavor.json");
+  const root = await realpath(cwd);
+  await assertSafeManagedPath(configPath, root);
+  try {
+    await lstat(configPath);
+    return;
+  } catch (error) {
+    if (!isMissingPathError(error)) throw error;
+  }
+  const example = {
+    providers: {
+      pkce: {
+        type: "oauth-callback",
+        apiType: "anthropic",
+        authorizationUrl: "http://127.0.0.1:8091/authorize",
+        tokenUrl: "http://127.0.0.1:8091/token",
+        clientId: "flavor-code-cli",
+        scope: "models:read models:use",
+        thinkingEffort: "high"
+      }
+    },
+    agents: {
+      main: { model: "pkce:bootstrap" },
+      subagent: { model: "pkce:bootstrap" }
+    },
+    maxSubagents: 3,
+    permissionMode: "default",
+    language: "zh-CN"
+  };
+  await writeFile(configPath, JSON.stringify(example, null, 2) + "\n");
+}
+async function initializeFlavor(cwd) {
+  await ensureFlavorDirectories(cwd);
+  await createExampleFlavorConfig(cwd);
+  const facts = await inspectProject(cwd);
+  const path = join(cwd, "FLAVOR.md");
+  const root = await realpath(cwd);
+  await assertSafeManagedPath(path, root);
+  let existing;
+  try {
+    existing = await readFile(path, "utf8");
+  } catch (error) {
+    if (!isMissingPathError(error)) throw error;
+  }
+  const newline = existing === void 0 ? "\n" : detectNewline(existing);
+  const generated = renderGeneratedSection(facts, newline);
+  const content = mergeGeneratedSection(existing, generated);
+  await writeFile(path, content);
+  await addSessionsToGitignore(cwd);
+  return { path, created: existing === void 0, content, facts };
+}
+
+export {
+  inspectProject,
+  initializeFlavor
+};