@joshuafolkken/kit 1.1240.0 → 1.1370.0

package/dist/hooks/session-lang.js

@@ -2,30 +2,428 @@
 import {
   session_language
 } from "./chunk-6V5OPIUU.js";
+import {
+  agent_role_profile,
+  detached_launch,
+  git_common_directory,
+  run_headless
+} from "./chunk-SYSRHRWU.js";
 import {
   josh_environment_file
-} from "./chunk-WPALEIRX.js";
-import "./chunk-RKUAD3I6.js";
+} from "./chunk-Z5TMJIPW.js";
+import {
+  agent_session_environment,
+  json_value,
+  process_identity,
+  run_carry
+} from "./chunk-NZN2UFI6.js";
+import {
+  stamp_file
+} from "./chunk-NEC4AT4Z.js";
 
 // scripts/josh/session-language-cli.ts
 import { fileURLToPath } from "node:url";
+
+// scripts/backlog/backlogrun-launch.ts
+import { randomUUID } from "node:crypto";
+
+// scripts/agent/agent-diagnostics.ts
+import { spawnSync } from "node:child_process";
+import semver from "semver";
+var DIAGNOSTIC_TIMEOUT_MS = 1e4;
+var AUTH_ARGS = ["login", "status"];
+var VERSION_ARGS = ["--version"];
+var PROVIDER_CLI_TABLE = {
+  anthropic: { command: "claude", name: "Claude Code", update: "claude update" },
+  openai: { command: "codex", name: "Codex CLI", update: "npm install -g @openai/codex@latest" }
+};
+var MODEL_CLI_FLOORS = /* @__PURE__ */ new Map([
+  ["claude-opus-5-5", "2.1.280"],
+  ["gpt-6-sol", "0.155.0"],
+  ["gpt-6.1-sol", "0.159.1"]
+]);
+var default_ports = {
+  run(command, args) {
+    const outcome = spawnSync(command, [...args], {
+      encoding: "utf8",
+      timeout: DIAGNOSTIC_TIMEOUT_MS
+    });
+    return { ...outcome, status: outcome.status ?? void 0 };
+  }
+};
+function nonempty(value) {
+  const trimmed = value?.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function note_of(outcome) {
+  if (outcome.error !== void 0) return outcome.error.message;
+  return nonempty(outcome.stderr) ?? nonempty(outcome.stdout) ?? "unknown error";
+}
+function rejected(note) {
+  return { kind: "rejected", note };
+}
+function version_of(outcome) {
+  if (outcome.error !== void 0 || outcome.status !== 0) return void 0;
+  return semver.coerce(outcome.stdout ?? "", { includePrerelease: true })?.version;
+}
+function version_note(cli, model, floor, found) {
+  return `${cli.name} ${found} cannot run ${model}; it needs ${floor} or later \u2014 run \`${cli.update}\`, then retry`;
+}
+function check_version(model, cli, ports) {
+  const floor = MODEL_CLI_FLOORS.get(model);
+  if (floor === void 0) return { kind: "ready" };
+  const outcome = ports.run(cli.command, VERSION_ARGS);
+  const found = version_of(outcome);
+  if (found === void 0) {
+    return rejected(`${cli.name} version could not be read: ${note_of(outcome)}`);
+  }
+  return semver.gte(found, floor) ? { kind: "ready" } : rejected(version_note(cli, model, floor, found));
+}
+function check_auth(cli, ports) {
+  const outcome = ports.run(cli.command, AUTH_ARGS);
+  if (outcome.error !== void 0) {
+    return rejected(`${cli.name} is unavailable: ${note_of(outcome)}`);
+  }
+  return outcome.status === 0 ? { kind: "ready" } : rejected(`Codex authentication is unavailable: ${note_of(outcome)}`);
+}
+function check(profile, ports = default_ports) {
+  const cli = PROVIDER_CLI_TABLE[profile.provider];
+  const version = check_version(profile.model, cli, ports);
+  if (version.kind === "rejected" || profile.provider === "anthropic") return version;
+  return check_auth(cli, ports);
+}
+var agent_diagnostics = { check };
+
+// scripts/agent/claude-agent-argv.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var AGENT_COMMAND = "claude";
+var AGENT_FLAGS = ["-p", "--verbose", "--output-format", "stream-json"];
+var MODEL_FLAG = "--model";
+var EFFORT_FLAG = "--effort";
+var RESUME_FLAG = "--resume";
+var SESSION_ID_FLAG = "--session-id";
+var LAUNCHED_TOOLS = [
+  "Bash",
+  "Read",
+  "Edit",
+  "Write",
+  "Agent",
+  "Skill",
+  "ToolSearch",
+  "SendMessage",
+  "TaskStop",
+  "Monitor",
+  "TodoWrite",
+  "WebSearch",
+  "WebFetch"
+];
+var TOOLS_FLAG = "--tools";
+var STRICT_MCP_FLAG = "--strict-mcp-config";
+var MCP_CONFIG_FLAG = "--mcp-config";
+var PROJECT_MCP_FILE = ".mcp.json";
+function session_id_flags(session_id) {
+  return session_id === void 0 ? [] : [SESSION_ID_FLAG, session_id];
+}
+function tool_flags(cwd = process.cwd()) {
+  const mcp_config = path.join(cwd, PROJECT_MCP_FILE);
+  const mcp_flags = existsSync(mcp_config) ? [STRICT_MCP_FLAG, MCP_CONFIG_FLAG, mcp_config] : [STRICT_MCP_FLAG];
+  return [TOOLS_FLAG, LAUNCHED_TOOLS.join(","), ...mcp_flags];
+}
+function build(invocation, profile, session_id, cwd) {
+  return {
+    command: AGENT_COMMAND,
+    args: [
+      ...AGENT_FLAGS,
+      ...tool_flags(cwd),
+      ...session_id_flags(session_id),
+      MODEL_FLAG,
+      profile.model,
+      EFFORT_FLAG,
+      profile.effort,
+      invocation
+    ]
+  };
+}
+function build_resume(invocation, profile, session_id, cwd) {
+  return {
+    command: AGENT_COMMAND,
+    args: [
+      ...AGENT_FLAGS,
+      ...tool_flags(cwd),
+      RESUME_FLAG,
+      session_id,
+      MODEL_FLAG,
+      profile.model,
+      EFFORT_FLAG,
+      profile.effort,
+      invocation
+    ]
+  };
+}
+function with_profile(invocation, profile) {
+  return { kind: "argv", argv: build(invocation, profile), profile };
+}
+function resolve(invocation, role, environment = process.env) {
+  const result = agent_role_profile.resolve(role, environment);
+  if (result.kind === "rejected") return result;
+  return with_profile(invocation, result.profile);
+}
+var claude_agent_argv = {
+  AGENT_COMMAND,
+  AGENT_FLAGS,
+  LAUNCHED_TOOLS,
+  build,
+  build_resume,
+  resolve
+};
+
+// scripts/agent/codex-agent-argv.ts
+import { lstatSync, mkdirSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/observations/observation-ledger.ts
+var OBSERVATION_LEDGER_DIRECTORY = ".josh/observations";
+var LEDGER_FILE_EXTENSION = ".md";
+var LEGACY_LEDGER_FILE = `legacy${LEDGER_FILE_EXTENSION}`;
+
+// scripts/agent/codex-agent-argv.ts
+var AGENT_COMMAND2 = "codex";
+var AGENT_FLAGS2 = ["exec", "--sandbox", "workspace-write"];
+var MODEL_FLAG2 = "--model";
+var CONFIG_FLAG = "-c";
+var JSON_FLAG = "--json";
+var NETWORK_CONFIG = "sandbox_workspace_write.network_access=true";
+var SQLITE_CACHE_PATH = ["node_modules", ".cache", "josh", "openai"];
+var EPHEMERAL_FLAG = "--ephemeral";
+var ADD_DIRECTORY_FLAG = "--add-dir";
+var GIT_DIRECTORY = ".git";
+var LEDGER_DIRECTORY = path2.dirname(OBSERVATION_LEDGER_DIRECTORY);
+function effort_config(profile) {
+  return `model_reasoning_effort="${profile.effort}"`;
+}
+function sqlite_config(cwd) {
+  return `sqlite_home=${JSON.stringify(path2.resolve(cwd, ...SQLITE_CACHE_PATH))}`;
+}
+function persistence_arguments(profile) {
+  return profile.role === agent_role_profile.WORKER ? [] : [EPHEMERAL_FLAG];
+}
+function ensure_ledger_directory(directory) {
+  const current = lstatSync(directory, { throwIfNoEntry: false });
+  if (current === void 0) mkdirSync(directory, { recursive: true });
+  else if (!current.isDirectory() || current.isSymbolicLink()) {
+    throw new Error(`Ledger directory must be a real directory: ${directory}`);
+  }
+}
+function ledger_arguments(common_directory, profile) {
+  if (common_directory === void 0 || profile.role !== agent_role_profile.WORKER) return [];
+  if (path2.basename(common_directory) !== GIT_DIRECTORY) return [];
+  const directory = path2.join(path2.dirname(common_directory), LEDGER_DIRECTORY);
+  ensure_ledger_directory(directory);
+  return [ADD_DIRECTORY_FLAG, directory];
+}
+function lane_arguments(cwd, profile) {
+  const common_directory = git_common_directory.resolve(cwd);
+  const additional_directory = common_directory === void 0 ? [] : [ADD_DIRECTORY_FLAG, common_directory];
+  return [
+    CONFIG_FLAG,
+    sqlite_config(cwd),
+    ...persistence_arguments(profile),
+    ...additional_directory,
+    ...ledger_arguments(common_directory, profile)
+  ];
+}
+function build2(invocation, profile, cwd) {
+  return {
+    command: AGENT_COMMAND2,
+    args: [
+      ...AGENT_FLAGS2,
+      MODEL_FLAG2,
+      profile.model,
+      CONFIG_FLAG,
+      effort_config(profile),
+      CONFIG_FLAG,
+      NETWORK_CONFIG,
+      ...cwd === void 0 ? [] : lane_arguments(cwd, profile),
+      JSON_FLAG,
+      invocation
+    ]
+  };
+}
+var codex_agent_argv = { build: build2 };
+
+// scripts/agent/agent-argv.ts
+function build3(invocation, profile, cwd, session_id) {
+  return profile.provider === "openai" ? codex_agent_argv.build(invocation, profile, cwd) : claude_agent_argv.build(invocation, profile, session_id, cwd);
+}
+function build_resume2(invocation, profile, session_id, cwd) {
+  return profile.provider === "openai" ? codex_agent_argv.build(invocation, profile, cwd) : claude_agent_argv.build_resume(invocation, profile, session_id, cwd);
+}
+function with_profile_in(invocation, profile, cwd, session_id) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build3(invocation, profile, cwd, session_id), profile };
+}
+function with_resume_in(invocation, profile, session_id, cwd) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build_resume2(invocation, profile, session_id, cwd), profile };
+}
+function with_profile2(invocation, profile) {
+  const diagnostic = agent_diagnostics.check(profile);
+  if (diagnostic.kind === "rejected") return diagnostic;
+  return { kind: "argv", argv: build3(invocation, profile), profile };
+}
+function resolve2(invocation, role, environment = process.env) {
+  const resolved = agent_role_profile.resolve(role, environment);
+  return resolved.kind === "rejected" ? resolved : with_profile2(invocation, resolved.profile);
+}
+function resume_argv(invocation, profile, phase, cwd) {
+  if (profile !== void 0) {
+    return with_profile_in(invocation, agent_role_profile.with_phase_effort(profile, phase), cwd);
+  }
+  const resolved = agent_role_profile.resolve(agent_role_profile.WORKER, process.env, phase);
+  return resolved.kind === "rejected" ? resolved : with_profile_in(invocation, resolved.profile, cwd);
+}
+function resolve_in(invocation, role, cwd, environment = process.env) {
+  const resolved = agent_role_profile.resolve(role, environment);
+  return resolved.kind === "rejected" ? resolved : with_profile_in(invocation, resolved.profile, cwd);
+}
+var agent_argv = {
+  resolve: resolve2,
+  resolve_in,
+  resume_argv,
+  with_profile: with_profile2,
+  with_profile_in,
+  with_resume_in
+};
+
+// scripts/backlog/backlogrun-launch.ts
+import { z } from "zod";
+var LAUNCH_PREFIX = "josh-backlogrun-launch-";
+var LOG_PREFIX = "josh-backlogrun-log-";
+var LOG_SUFFIX = ".log";
+var launch_schema = z.object({
+  pid: z.number(),
+  start: z.string().optional(),
+  session: z.string().optional()
+});
+function launch_path(git_directory) {
+  return stamp_file.stamp_path(LAUNCH_PREFIX, git_directory);
+}
+function log_path(git_directory) {
+  return stamp_file.stamp_path(LOG_PREFIX, git_directory, LOG_SUFFIX);
+}
+function read_launch(target) {
+  return json_value.parse_with(stamp_file.read_stamp_text(target) ?? "", launch_schema);
+}
+function is_launch_live(record) {
+  if (record === void 0) return false;
+  return process_identity.is_same_process(record.pid, record.start) !== false;
+}
+function is_carry_live(read) {
+  return read.kind === "carried" && run_carry.is_owner_live(read.carry);
+}
+function is_running(git_directory) {
+  if (is_carry_live(run_carry.read_carry(run_carry.carry_path(git_directory)))) return true;
+  return is_launch_live(read_launch(launch_path(git_directory)));
+}
+function chosen_environment(provider, environment = process.env) {
+  return {
+    ...environment,
+    ...agent_session_environment.removed_environment(environment),
+    [agent_role_profile.CODEX_SESSION_KEY]: void 0,
+    [agent_role_profile.HANDED_PROVIDER_KEY]: provider
+  };
+}
+function session_for(provider) {
+  return provider === "anthropic" ? randomUUID() : void 0;
+}
+function argv_of(invocation, provider, worktree, session) {
+  const environment = chosen_environment(provider);
+  const resolved = agent_role_profile.resolve(agent_role_profile.SCHEDULER, environment);
+  if (resolved.kind === "rejected") return resolved;
+  return agent_argv.with_profile_in(invocation, resolved.profile, worktree, session);
+}
+function note_to_stderr(note) {
+  console.error(`backlogrun: ${note}`);
+}
+function record_launch(git_directory, pid, session) {
+  const started = process_identity.read_start(pid);
+  stamp_file.replace_stamp(launch_path(git_directory), { pid, start: started, session });
+}
+function spawn_parent(argv, provider, target) {
+  const environment = {
+    ...run_headless.environment(),
+    [agent_role_profile.CODEX_SESSION_KEY]: void 0,
+    [agent_role_profile.HANDED_PROVIDER_KEY]: provider
+  };
+  const log = log_path(target.git_directory);
+  return detached_launch.launch(
+    {
+      argv: argv.argv,
+      cwd: target.worktree,
+      env: environment,
+      log_path: log,
+      profile: argv.profile
+    },
+    note_to_stderr
+  );
+}
+function start(invocation, provider, target) {
+  const session = session_for(provider);
+  const built = argv_of(invocation, provider, target.worktree, session);
+  if (built.kind === "rejected") return { kind: "failed", note: built.note };
+  const result = spawn_parent(built, provider, target);
+  if (result.kind === "failed") return result;
+  record_launch(target.git_directory, result.pid, session);
+  const launched = { pid: result.pid, session, log_path: log_path(target.git_directory) };
+  return { kind: "launched", launched };
+}
+var backlogrun_launch = {
+  argv_of,
+  chosen_environment,
+  is_running,
+  start
+};
+
+// scripts/josh/session-language-cli.ts
 var { DEFAULT_SESSION_LANG, ENV_KEY, resolve_session_lang } = session_language;
-var ENGLISH_OPT_IN_LANG = "en";
+var BOARD_LINE = "A backlogrun is live here: answer a progress question with `pnpm josh run:board --chat`, verbatim in one code block.";
+var LIVE_PORTS = {
+  repository_directory: run_carry.repository_directory,
+  is_running: backlogrun_launch.is_running
+};
 function format_line(resolution) {
-  const suffix = resolution.is_default ? ` (default; set ${ENV_KEY}=${ENGLISH_OPT_IN_LANG} for English)` : "";
-  return `Session language (${ENV_KEY}): ${resolution.lang}${suffix}`;
+  if (resolution.is_default) return "";
+  return `Session language (${ENV_KEY}): ${resolution.lang}`;
+}
+async function is_run_live(ports = LIVE_PORTS) {
+  try {
+    const git_directory = await ports.repository_directory();
+    return git_directory !== void 0 && ports.is_running(git_directory);
+  } catch {
+    return false;
+  }
+}
+function prompt_lines(resolution, is_live) {
+  return [format_line(resolution), is_live ? BOARD_LINE : ""].filter((line) => line !== "");
 }
-function main() {
+async function main() {
   josh_environment_file.load_environment_file();
-  console.info(format_line(resolve_session_lang()));
+  const lines = prompt_lines(resolve_session_lang(), await is_run_live());
+  for (const line of lines) console.info(line);
 }
 var session_language_cli = {
+  BOARD_LINE,
   DEFAULT_SESSION_LANG,
   ENV_KEY,
   format_line,
+  is_run_live,
+  prompt_lines,
   resolve_session_lang
 };
-if (process.argv[1] === fileURLToPath(import.meta.url)) main();
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main();
 export {
   session_language_cli
 };