@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-IYY3HQAD.js

@@ -0,0 +1,484 @@
+import {
+  discoverGeminiInstructionSources,
+  findMarkdownImports
+} from "./chunk-UDNNAQN5.js";
+import {
+  expandInstructionPath,
+  findExactNames,
+  isDirectory,
+  listRuleFiles,
+  readInstructionFiles,
+  readInstructionText,
+  userHomeDir
+} from "./chunk-S6I4KISU.js";
+import {
+  mutateUserState,
+  readUserStateField
+} from "./chunk-ZH4G3FU5.js";
+import {
+  normalizeCodexHomePath,
+  readTomlValues
+} from "./chunk-BD3PGW6A.js";
+import {
+  getUserInstructionsTargetPath,
+  isShippedUserAgentsTemplate,
+  sha256Text
+} from "./chunk-RIMARPCF.js";
+import {
+  getUserConfigDir
+} from "./chunk-56WPYDJH.js";
+
+// src/core/instructions-import/staged-imports.ts
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var MANIFEST = "manifest.json";
+function getImportsDir() {
+  return join(getUserConfigDir(), "imports");
+}
+function readStagedImport(dir) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(dir, MANIFEST), "utf8"));
+    if (manifest?.schema !== 1 || typeof manifest.id !== "string") return void 0;
+    return { id: manifest.id, dir, manifest };
+  } catch {
+    return void 0;
+  }
+}
+function listStagedImports() {
+  const root = getImportsDir();
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => !entry.startsWith(".")).map((entry) => readStagedImport(join(root, entry))).filter((staged) => staged !== void 0).sort((a, b) => b.manifest.createdAt.localeCompare(a.manifest.createdAt));
+}
+function findPendingImport() {
+  return listStagedImports().find((staged) => staged.manifest.status === "staged");
+}
+
+// src/core/instructions-import/offer.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/core/providers/claude/instruction-sources.ts
+import { existsSync } from "fs";
+import { dirname, join as join2, relative } from "path";
+var AGENT = "claude";
+var MAX_IMPORT_HOPS = 5;
+var TRAILING_PUNCTUATION = /[.,;:!?)\]'"]+$/;
+function resolveClaudeUserConfigDir(env) {
+  return env.CLAUDE_CONFIG_DIR?.trim() || join2(userHomeDir(env), ".claude");
+}
+function importReferences(text, file, env) {
+  const imports = findMarkdownImports(text);
+  const references = imports.map((entry) => ({
+    line: entry.line,
+    token: entry.path,
+    path: expandInstructionPath(entry.path, env, dirname(file))
+  }));
+  const perLine = /* @__PURE__ */ new Map();
+  for (const entry of imports) perLine.set(entry.line, (perLine.get(entry.line) ?? 0) + 1);
+  const onlyImports = /* @__PURE__ */ new Set();
+  text.split(/\r?\n/).forEach((rawLine, index) => {
+    const words = rawLine.trim().split(/\s+/).filter(Boolean);
+    if (words.length > 0 && words.length === perLine.get(index + 1) && words.every((w) => w[0] === "@")) {
+      onlyImports.add(index + 1);
+    }
+  });
+  return { references, onlyImports };
+}
+function looksLikePath(token) {
+  const bare = token.replace(TRAILING_PUNCTUATION, "");
+  return bare.includes("/") || bare.includes(".") || bare.startsWith("~");
+}
+function addFile(path, kind, discovery, seen, env, extra = {}, hops = 0) {
+  const read = readInstructionText(path);
+  if (!read.ok) {
+    discovery.issues.push({
+      agent: AGENT,
+      path,
+      problem: read.problem,
+      ...extra.includedFrom ? { includedFrom: extra.includedFrom } : {}
+    });
+    return false;
+  }
+  if (seen.has(read.identity)) return true;
+  seen.add(read.identity);
+  const source = {
+    id: path,
+    path,
+    kind,
+    reaches: [AGENT],
+    text: read.text,
+    identity: read.identity,
+    ...extra
+  };
+  discovery.sources.push(source);
+  const { references, onlyImports } = importReferences(read.text, path, env);
+  const resolvedLines = /* @__PURE__ */ new Set();
+  const failedLines = /* @__PURE__ */ new Set();
+  for (const reference of references) {
+    const target = existsSync(reference.path) ? reference.path : void 0;
+    if (!target) {
+      if (looksLikePath(reference.token)) {
+        discovery.issues.push({
+          agent: AGENT,
+          path: reference.path,
+          problem: "not-found",
+          includedFrom: path
+        });
+      }
+      failedLines.add(reference.line);
+      continue;
+    }
+    if (hops + 1 > MAX_IMPORT_HOPS) {
+      discovery.issues.push({
+        agent: AGENT,
+        path: target,
+        problem: "too-deep",
+        includedFrom: path
+      });
+      failedLines.add(reference.line);
+      continue;
+    }
+    const ok = addFile(target, "include", discovery, seen, env, { includedFrom: path }, hops + 1);
+    (ok ? resolvedLines : failedLines).add(reference.line);
+  }
+  const includeLines = [...onlyImports].filter(
+    (line) => resolvedLines.has(line) && !failedLines.has(line)
+  );
+  if (includeLines.length > 0) source.includeLines = includeLines;
+  return true;
+}
+function isPathScopedRule(text) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
+  return match !== null && /^paths\s*:/m.test(match[1] ?? "");
+}
+function ruleName(rulesDir, path) {
+  return relative(rulesDir, path).replace(/\.md$/i, "").split(/[\\/]/).join("-");
+}
+function discoverClaudeInstructionSources(env = process.env) {
+  const home = resolveClaudeUserConfigDir(env);
+  const discovery = {
+    agent: AGENT,
+    home,
+    homeFound: isDirectory(home),
+    sources: [],
+    issues: []
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const memory = join2(home, "CLAUDE.md");
+  if (existsSync(memory)) addFile(memory, "instructions", discovery, seen, env);
+  const rulesDir = join2(home, "rules");
+  for (const path of listRuleFiles(rulesDir, { recursive: true })) {
+    const before = discovery.sources.length;
+    if (!addFile(path, "rule", discovery, seen, env)) continue;
+    const rule = discovery.sources[before];
+    if (rule?.path === path && isPathScopedRule(rule.text)) {
+      rule.pathScoped = true;
+      rule.ruleName = ruleName(rulesDir, path);
+    }
+  }
+  return discovery;
+}
+
+// src/core/providers/codex/instruction-sources.ts
+import { createHash } from "crypto";
+import { join as join3 } from "path";
+var AGENT2 = "codex";
+var GLOBAL_INSTRUCTION_NAMES = ["AGENTS.override.md", "AGENTS.md"];
+var DEVELOPER_INSTRUCTIONS_KEY = "developer_instructions";
+function resolveCodexUserHome(env) {
+  const explicit = env.CODEX_HOME?.trim();
+  return explicit ? normalizeCodexHomePath(explicit) : join3(userHomeDir(env), ".codex");
+}
+function discoverCodexInstructionSources(env = process.env) {
+  const home = resolveCodexUserHome(env);
+  const discovery = {
+    agent: AGENT2,
+    home,
+    homeFound: isDirectory(home),
+    sources: [],
+    issues: []
+  };
+  for (const path of findExactNames(home, GLOBAL_INSTRUCTION_NAMES)) {
+    const read = readInstructionText(path);
+    if (!read.ok) {
+      discovery.issues.push({ agent: AGENT2, path, problem: read.problem });
+      continue;
+    }
+    if (read.text.trim() === "") continue;
+    discovery.sources.push({
+      id: path,
+      path,
+      kind: "instructions",
+      reaches: [AGENT2],
+      text: read.text,
+      identity: read.identity
+    });
+    break;
+  }
+  const configPath = join3(home, "config.toml");
+  const config = readInstructionText(configPath);
+  if (config.ok) {
+    const value = readTomlValues(config.text).get(DEVELOPER_INSTRUCTIONS_KEY);
+    if (typeof value === "string" && value.trim() !== "") {
+      const id = `${configPath}#${DEVELOPER_INSTRUCTIONS_KEY}`;
+      discovery.sources.push({
+        id,
+        path: configPath,
+        kind: "setting",
+        reaches: [AGENT2],
+        text: value,
+        identity: `setting:${createHash("sha256").update(id).digest("hex")}`
+      });
+    }
+  } else if (config.problem !== "not-found") {
+    discovery.issues.push({ agent: AGENT2, path: configPath, problem: config.problem });
+  }
+  return discovery;
+}
+
+// src/core/providers/grok/instruction-sources.ts
+import { join as join4 } from "path";
+var AGENT3 = "grok";
+var GROK_INSTRUCTION_FILENAMES = [
+  "Agents.md",
+  "Claude.md",
+  "CLAUDE.md",
+  "CLAUDE.local.md",
+  "AGENT.md",
+  "AGENTS.md"
+];
+function resolveGrokUserHome(env) {
+  const explicit = env.GROK_HOME?.trim();
+  return explicit ? expandInstructionPath(explicit, env) : join4(userHomeDir(env), ".grok");
+}
+function parseSwitch(raw) {
+  const value = raw?.trim().toLowerCase();
+  if (!value) return void 0;
+  if (["1", "true", "yes", "on"].includes(value)) return true;
+  if (["0", "false", "no", "off"].includes(value)) return false;
+  return void 0;
+}
+function compatEnabled(vendor, cell, env, config) {
+  const fromEnv = parseSwitch(env[`GROK_${vendor.toUpperCase()}_${cell.toUpperCase()}_ENABLED`]);
+  if (fromEnv !== void 0) return fromEnv;
+  const fromConfig = config.get(`compat.${vendor}.${cell}`);
+  return typeof fromConfig === "boolean" ? fromConfig : true;
+}
+function discoverGrokInstructionSources(env = process.env) {
+  const home = resolveGrokUserHome(env);
+  const discovery = {
+    agent: AGENT3,
+    home,
+    homeFound: isDirectory(home),
+    sources: [],
+    issues: []
+  };
+  const configRead = readInstructionText(join4(home, "config.toml"));
+  const config = configRead.ok ? readTomlValues(configRead.text) : /* @__PURE__ */ new Map();
+  const instructionFiles = [...findExactNames(home, GROK_INSTRUCTION_FILENAMES)];
+  const ruleFiles = [...listRuleFiles(join4(home, "rules"), { recursive: false })];
+  for (const vendor of ["claude", "cursor"]) {
+    const vendorHome = join4(userHomeDir(env), `.${vendor}`);
+    if (compatEnabled(vendor, "agents", env, config)) {
+      instructionFiles.push(...findExactNames(vendorHome, GROK_INSTRUCTION_FILENAMES));
+    }
+    if (compatEnabled(vendor, "rules", env, config)) {
+      ruleFiles.push(...listRuleFiles(join4(vendorHome, "rules"), { recursive: false }));
+    }
+  }
+  const extraDirs = config.get("paths.extra_rule_dirs");
+  for (const dir of Array.isArray(extraDirs) ? extraDirs : []) {
+    if (dir.startsWith("/") || dir.startsWith("~/")) {
+      ruleFiles.push(...listRuleFiles(expandInstructionPath(dir, env), { recursive: false }));
+    }
+  }
+  readInstructionFiles(AGENT3, instructionFiles, "instructions", discovery);
+  readInstructionFiles(AGENT3, ruleFiles, "rule", discovery);
+  return discovery;
+}
+
+// src/core/providers/instruction-sources.ts
+var DISCOVERERS = [
+  discoverClaudeInstructionSources,
+  discoverCodexInstructionSources,
+  discoverGrokInstructionSources,
+  discoverGeminiInstructionSources
+];
+function discoverAgentInstructionSources(env = process.env) {
+  const result = { agents: [], sources: [], issues: [] };
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const discover of DISCOVERERS) {
+    const discovery = discover(env);
+    result.agents.push({
+      agent: discovery.agent,
+      home: discovery.home,
+      homeFound: discovery.homeFound
+    });
+    result.issues.push(...discovery.issues);
+    for (const source of discovery.sources) {
+      const existing = byIdentity.get(source.identity);
+      if (!existing) {
+        byIdentity.set(source.identity, source);
+        result.sources.push(source);
+        continue;
+      }
+      for (const agent of source.reaches) {
+        if (!existing.reaches.includes(agent)) existing.reaches.push(agent);
+      }
+    }
+  }
+  return result;
+}
+
+// src/core/instructions-import/state.ts
+var INSTRUCTIONS_IMPORT_STATE_KEY = "instructionsImport";
+var NOTICE_FLAGS = ["noticeShown", "buildDefaultNoticeShown"];
+function isState(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return (record.status === "imported" || record.status === "declined") && typeof record.date === "string";
+}
+function readInstructionsImportState(options = {}) {
+  const value = readUserStateField(INSTRUCTIONS_IMPORT_STATE_KEY, options);
+  return isState(value) ? value : void 0;
+}
+function keptNoticeFlags(value) {
+  const kept = {};
+  if (!value || typeof value !== "object") return kept;
+  for (const flag of NOTICE_FLAGS) {
+    if (value[flag]) kept[flag] = true;
+  }
+  return kept;
+}
+function readNoticeFlag(flag, options) {
+  return keptNoticeFlags(readUserStateField(INSTRUCTIONS_IMPORT_STATE_KEY, options))[flag] === true;
+}
+function markNoticesShown(flags, options) {
+  mutateUserState((state) => {
+    const previous = state[INSTRUCTIONS_IMPORT_STATE_KEY];
+    state[INSTRUCTIONS_IMPORT_STATE_KEY] = {
+      ...previous && typeof previous === "object" ? previous : {},
+      ...Object.fromEntries(flags.map((flag) => [flag, true]))
+    };
+  }, options);
+}
+function readInstructionsImportNoticeShown(options = {}) {
+  return readNoticeFlag("noticeShown", options);
+}
+function markInstructionsImportNoticeShown(options = {}) {
+  markNoticesShown(["noticeShown"], options);
+}
+function readBuildDefaultNoticeShown(options = {}) {
+  return readNoticeFlag("buildDefaultNoticeShown", options);
+}
+function markBuildDefaultNoticeShown(options = {}) {
+  markNoticesShown(["buildDefaultNoticeShown", "noticeShown"], options);
+}
+function recordInstructionsImportState(update, options = {}) {
+  return mutateUserState((state) => {
+    const previous = state[INSTRUCTIONS_IMPORT_STATE_KEY];
+    const next = {
+      optimization: { status: "none" },
+      ...isState(previous) ? previous : keptNoticeFlags(previous),
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      ...update
+    };
+    state[INSTRUCTIONS_IMPORT_STATE_KEY] = next;
+    return next;
+  }, options).value;
+}
+function recordImportOptimization(optimization, options = {}) {
+  return mutateUserState((state) => {
+    const previous = state[INSTRUCTIONS_IMPORT_STATE_KEY];
+    if (!isState(previous)) return void 0;
+    const next = { ...previous, optimization };
+    state[INSTRUCTIONS_IMPORT_STATE_KEY] = next;
+    return next;
+  }, options).value;
+}
+
+// src/core/instructions-import/offer.ts
+var INSTRUCTIONS_IMPORT_CHECK_COMMAND = "build config instructions import --check";
+var INSTRUCTIONS_IMPORT_COMMAND = "build config instructions import";
+function hasOwnInstructionsFile() {
+  let text;
+  try {
+    text = readFileSync2(getUserInstructionsTargetPath(), "utf8");
+  } catch {
+    return false;
+  }
+  return text.trim() !== "" && !isShippedUserAgentsTemplate(sha256Text(text));
+}
+var agentsWithInstructionsByHomes = /* @__PURE__ */ new Map();
+function listAgentsWithGlobalInstructions(env = process.env) {
+  const key = JSON.stringify(
+    ["HOME", "CLAUDE_CONFIG_DIR", "CODEX_HOME", "GROK_HOME", "GEMINI_CLI_HOME"].map(
+      (name) => env[name] ?? null
+    )
+  );
+  let agents = agentsWithInstructionsByHomes.get(key);
+  if (agents === void 0) {
+    const discovery = discoverAgentInstructionSources(env);
+    const reached = new Set(
+      discovery.sources.filter((source) => source.text.trim() !== "").flatMap((s) => s.reaches)
+    );
+    agents = discovery.agents.map(({ agent }) => agent).filter((agent) => reached.has(agent));
+    agentsWithInstructionsByHomes.set(key, agents);
+  }
+  return agents;
+}
+function resolveStatus(state, unfinished, env) {
+  if (state) return state.status;
+  if (unfinished) return "eligible";
+  if (hasOwnInstructionsFile()) return "has-instructions";
+  return listAgentsWithGlobalInstructions(env).length > 0 ? "eligible" : "nothing-to-import";
+}
+function resolveInstructionsImportOffer(options = {}) {
+  const state = readInstructionsImportState();
+  const unfinished = state ? void 0 : findPendingImport();
+  const status = resolveStatus(state, unfinished !== void 0, options.env ?? process.env);
+  const eligible = status === "eligible";
+  return {
+    status,
+    eligible,
+    noticeShown: readInstructionsImportNoticeShown(),
+    ...state ? { decidedAt: state.date, version: state.version } : {},
+    ...unfinished ? { unfinishedSince: unfinished.manifest.createdAt } : {},
+    ...eligible ? { check: INSTRUCTIONS_IMPORT_CHECK_COMMAND, command: INSTRUCTIONS_IMPORT_COMMAND } : {}
+  };
+}
+function tryResolveInstructionsImportOffer(options = {}) {
+  try {
+    return resolveInstructionsImportOffer(options);
+  } catch {
+    return void 0;
+  }
+}
+function instructionsImportJsonField() {
+  const offer = tryResolveInstructionsImportOffer();
+  return offer ? { instructionsImport: offer } : {};
+}
+
+export {
+  discoverAgentInstructionSources,
+  MANIFEST,
+  getImportsDir,
+  findPendingImport,
+  readInstructionsImportState,
+  markInstructionsImportNoticeShown,
+  readBuildDefaultNoticeShown,
+  markBuildDefaultNoticeShown,
+  recordInstructionsImportState,
+  recordImportOptimization,
+  INSTRUCTIONS_IMPORT_CHECK_COMMAND,
+  INSTRUCTIONS_IMPORT_COMMAND,
+  listAgentsWithGlobalInstructions,
+  resolveInstructionsImportOffer,
+  tryResolveInstructionsImportOffer,
+  instructionsImportJsonField
+};
+//# sourceMappingURL=chunk-IYY3HQAD.js.map

package/dist/chunk-J2ICMYDA.js

@@ -0,0 +1,48 @@
+// src/core/git/git-quoted-path.ts
+var C_ESCAPE_BYTES = {
+  "\\": 92,
+  '"': 34,
+  t: 9,
+  n: 10,
+  r: 13,
+  a: 7,
+  b: 8,
+  f: 12,
+  v: 11
+};
+function decodeGitQuotedPathBody(body) {
+  const bytes = [];
+  for (let index = 0; index < body.length; index++) {
+    const char = String.fromCodePoint(body.codePointAt(index) ?? 0);
+    if (char !== "\\") {
+      bytes.push(...Buffer.from(char, "utf8"));
+      index += char.length - 1;
+      continue;
+    }
+    const next = body[index + 1];
+    if (next === void 0) {
+      bytes.push(92);
+      continue;
+    }
+    if (next >= "0" && next <= "7") {
+      const octal = body.slice(index + 1, index + 4).match(/^[0-7]{1,3}/)?.[0] ?? next;
+      bytes.push(Number.parseInt(octal, 8) & 255);
+      index += octal.length;
+      continue;
+    }
+    const escaped = String.fromCodePoint(body.codePointAt(index + 1) ?? 0);
+    const byte = C_ESCAPE_BYTES[escaped];
+    if (byte === void 0) {
+      bytes.push(...Buffer.from(escaped, "utf8"));
+    } else {
+      bytes.push(byte);
+    }
+    index += escaped.length;
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+
+export {
+  decodeGitQuotedPathBody
+};
+//# sourceMappingURL=chunk-J2ICMYDA.js.map