@kody-ade/kody-engine 0.4.70 → 0.4.72

package/dist/bin/kody.js

@@ -864,7 +864,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.70",
+  version: "0.4.72",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -879,6 +879,8 @@ var package_default = {
   scripts: {
     kody: "tsx bin/kody.ts",
     serve: "tsx bin/kody.ts serve",
+    "serve:vscode": "tsx bin/kody.ts serve vscode",
+    "serve:claude": "tsx bin/kody.ts serve claude",
     build: "tsup && node scripts/copy-assets.cjs",
     "check:modularity": "tsx scripts/check-script-modularity.ts",
     pretest: "pnpm check:modularity",
@@ -1720,6 +1722,7 @@ async function emit(sink, type, sessionId, suffix, payload) {
 // src/chat/modes/interactive.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import * as fs6 from "fs";
+import * as os from "os";
 import * as path6 from "path";
 
 // src/chat/inbox.ts
@@ -1881,6 +1884,45 @@ function commitTurn(cwd, sessionId, verbose) {
   const eventsRel = path6.relative(cwd, eventsFilePath(cwd, sessionId));
   const paths = [sessionRel, eventsRel].filter((p) => fs6.existsSync(path6.join(cwd, p)));
   if (paths.length === 0) return;
+  const startBranch = currentBranch2(cwd);
+  const eventsBranch = defaultBranch(cwd) ?? "main";
+  if (startBranch === eventsBranch) {
+    commitPathsAndPush(cwd, paths, sessionId, verbose, "HEAD");
+    return;
+  }
+  const stdio = verbose ? "inherit" : "pipe";
+  const exec = (args) => execFileSync2("git", args, { cwd, stdio });
+  const worktreeDir = fs6.mkdtempSync(path6.join(os.tmpdir(), "kody-events-"));
+  let worktreeAdded = false;
+  try {
+    exec(["fetch", "--quiet", "origin", eventsBranch]);
+    exec(["worktree", "add", "--detach", "--quiet", worktreeDir, `origin/${eventsBranch}`]);
+    worktreeAdded = true;
+    for (const rel of paths) {
+      const src = path6.join(cwd, rel);
+      const dst = path6.join(worktreeDir, rel);
+      fs6.mkdirSync(path6.dirname(dst), { recursive: true });
+      fs6.copyFileSync(src, dst);
+    }
+    commitPathsAndPush(worktreeDir, paths, sessionId, verbose, `HEAD:${eventsBranch}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody:chat:interactive] worktree commit failed: ${msg}
+`);
+  } finally {
+    if (worktreeAdded) {
+      try {
+        exec(["worktree", "remove", "--force", "--quiet", worktreeDir]);
+      } catch {
+      }
+    }
+    try {
+      fs6.rmSync(worktreeDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function commitPathsAndPush(cwd, paths, sessionId, verbose, pushSpec) {
   const stdio = verbose ? "inherit" : "pipe";
   const exec = (args) => execFileSync2("git", args, { cwd, stdio });
   try {
@@ -1894,7 +1936,7 @@ function commitTurn(cwd, sessionId, verbose) {
   }
   for (let attempt = 1; attempt <= 3; attempt++) {
     try {
-      exec(["push", "--quiet", "origin", "HEAD"]);
+      exec(["push", "--quiet", "origin", pushSpec]);
       return;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -1908,14 +1950,16 @@ function commitTurn(cwd, sessionId, verbose) {
 `);
       try {
         exec(["fetch", "--quiet", "origin"]);
-        const branch = currentBranch2(cwd);
-        if (branch) {
-          exec(["rebase", "--quiet", `origin/${branch}`]);
-        } else {
-          process.stderr.write(`[kody:chat:interactive] cannot rebase: no current branch
+        const upstream = pushSpec.includes(":") ? `origin/${pushSpec.split(":")[1]}` : (() => {
+          const branch = currentBranch2(cwd);
+          return branch ? `origin/${branch}` : null;
+        })();
+        if (!upstream) {
+          process.stderr.write(`[kody:chat:interactive] cannot rebase: no upstream resolved
 `);
           return;
         }
+        exec(["rebase", "--quiet", upstream]);
       } catch (rebaseErr) {
         const rmsg = rebaseErr instanceof Error ? rebaseErr.message : String(rebaseErr);
         process.stderr.write(`[kody:chat:interactive] rebase failed: ${rmsg}
@@ -1925,6 +1969,20 @@ function commitTurn(cwd, sessionId, verbose) {
     }
   }
 }
+function defaultBranch(cwd) {
+  try {
+    const out = execFileSync2(
+      "git",
+      ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+      { cwd, stdio: ["ignore", "pipe", "ignore"] }
+    );
+    const symbolic = out.toString("utf-8").trim();
+    if (symbolic.startsWith("origin/")) return symbolic.slice("origin/".length);
+    return symbolic || null;
+  } catch {
+    return null;
+  }
+}
 function currentBranch2(cwd) {
   try {
     const out = execFileSync2("git", ["symbolic-ref", "--short", "HEAD"], {
@@ -3020,7 +3078,7 @@ function errMsg(err) {
 // src/litellm.ts
 import { execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
 import * as fs10 from "fs";
-import * as os from "os";
+import * as os2 from "os";
 import * as path9 from "path";
 async function checkLitellmHealth(url) {
   try {
@@ -3068,13 +3126,13 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
       throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
     }
   }
-  const configPath = path9.join(os.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
+  const configPath = path9.join(os2.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
   fs10.writeFileSync(configPath, generateLitellmConfigYaml(model));
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   const args = cmd === "litellm" ? ["--config", configPath, "--port", port] : ["-m", "litellm", "--config", configPath, "--port", port];
   const dotenvVars = readDotenvApiKeys(projectDir);
-  const logPath = path9.join(os.tmpdir(), `kody-litellm-${Date.now()}.log`);
+  const logPath = path9.join(os2.tmpdir(), `kody-litellm-${Date.now()}.log`);
   const outFd = fs10.openSync(logPath, "w");
   const child = spawn2(cmd, args, {
     stdio: ["ignore", outFd, outFd],
@@ -3304,13 +3362,13 @@ function commitAndPush(branch, agentMessage, cwd) {
     }
   }
 }
-function hasCommitsAhead(branch, defaultBranch, cwd) {
+function hasCommitsAhead(branch, defaultBranch2, cwd) {
   try {
-    const out = git(["rev-list", "--count", `origin/${defaultBranch}..${branch}`], cwd);
+    const out = git(["rev-list", "--count", `origin/${defaultBranch2}..${branch}`], cwd);
     return parseInt(out, 10) > 0;
   } catch {
     try {
-      const out = git(["rev-list", "--count", `${defaultBranch}..${branch}`], cwd);
+      const out = git(["rev-list", "--count", `${defaultBranch2}..${branch}`], cwd);
       return parseInt(out, 10) > 0;
     } catch {
       return false;
@@ -3576,7 +3634,7 @@ var advanceFlow = async (ctx, profile) => {
 
 // src/scripts/buildSyntheticPlugin.ts
 import * as fs12 from "fs";
-import * as os2 from "os";
+import * as os3 from "os";
 import * as path11 from "path";
 function getPluginsCatalogRoot() {
   const here = path11.dirname(new URL(import.meta.url).pathname);
@@ -3599,7 +3657,7 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (!needsSynthetic) return;
   const catalog = getPluginsCatalogRoot();
   const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const root = path11.join(os2.tmpdir(), `kody-synth-${runId}`);
+  const root = path11.join(os3.tmpdir(), `kody-synth-${runId}`);
   fs12.mkdirSync(path11.join(root, ".claude-plugin"), { recursive: true });
   const resolvePart = (bucket, entry) => {
     const local = path11.join(profile.dir, bucket, entry);
@@ -3836,6 +3894,11 @@ var commitAndPush2 = async (ctx, profile) => {
     } catch {
     }
   }
+  if (ctx.data.verifyOk === false) {
+    ctx.data.commitResult = { committed: false, pushed: false, skippedReason: "verifyFailed" };
+    ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
+    return;
+  }
   const markerMissing = ctx.data.agentMarkerMissing === true;
   if (ctx.data.agentDone === false && !markerMissing) {
     ctx.data.commitResult = { committed: false, pushed: false, skippedReason: "agentDone=false" };
@@ -4803,10 +4866,10 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync11 } from "child_process";
 import * as fs17 from "fs";
-import * as os3 from "os";
+import * as os4 from "os";
 import * as path17 from "path";
 var diagMcp = async (_ctx) => {
-  const home = os3.homedir();
+  const home = os4.homedir();
   const cacheDir = path17.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
@@ -6467,14 +6530,6 @@ var finishFlow = async (ctx, profile, _agentResult, args) => {
 
 // src/branch.ts
 import { execFileSync as execFileSync15 } from "child_process";
-var UncommittedChangesError = class extends Error {
-  constructor(branch) {
-    super(`Uncommitted changes on branch '${branch}' \u2014 refusing to run to protect work in progress`);
-    this.branch = branch;
-    this.name = "UncommittedChangesError";
-  }
-  branch;
-};
 function git2(args, cwd) {
   return execFileSync15("git", args, {
     encoding: "utf-8",
@@ -6491,8 +6546,15 @@ function deriveBranchName(issueNumber, title) {
 function getCurrentBranch(cwd) {
   return git2(["branch", "--show-current"], cwd);
 }
-function hasUncommittedChanges(cwd) {
-  return git2(["status", "--porcelain", "--untracked-files=no"], cwd).length > 0;
+function resetWorkingTree(cwd) {
+  try {
+    execFileSync15("git", ["reset", "--hard", "HEAD"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+  } catch {
+  }
+  try {
+    execFileSync15("git", ["clean", "-fd"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+  } catch {
+  }
 }
 function checkoutPrBranch(prNumber, cwd) {
   const env = {
@@ -6539,14 +6601,13 @@ function mergeBase(baseBranch, cwd) {
     return "error";
   }
 }
-function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd, baseBranch) {
+function ensureFeatureBranch(issueNumber, title, defaultBranch2, cwd, baseBranch) {
   const branchName = deriveBranchName(issueNumber, title);
+  resetWorkingTree(cwd);
   const current = getCurrentBranch(cwd);
   if (current === branchName) {
-    if (hasUncommittedChanges(cwd)) throw new UncommittedChangesError(branchName);
     return { branch: branchName, created: false };
   }
-  if (hasUncommittedChanges(cwd)) throw new UncommittedChangesError(current || "(detached)");
   try {
     git2(["fetch", "origin"], cwd);
   } catch {
@@ -6557,7 +6618,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd, baseBranch)
     originBranchExists = true;
   } catch {
   }
-  if (originBranchExists && baseBranch && baseBranch !== defaultBranch) {
+  if (originBranchExists && baseBranch && baseBranch !== defaultBranch2) {
     let baseExists = false;
     try {
       git2(["rev-parse", "--verify", `origin/${baseBranch}`], cwd);
@@ -6606,8 +6667,8 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd, baseBranch)
     return { branch: branchName, created: false };
   } catch {
   }
-  let forkPoint = defaultBranch;
-  if (baseBranch && baseBranch !== defaultBranch) {
+  let forkPoint = defaultBranch2;
+  if (baseBranch && baseBranch !== defaultBranch2) {
     try {
       git2(["rev-parse", "--verify", `origin/${baseBranch}`], cwd);
       forkPoint = baseBranch;
@@ -6979,11 +7040,11 @@ function detectOwnerRepo(cwd) {
   if (!m) return null;
   return { owner: m[1], repo: m[2] };
 }
-function makeConfig(pm, ownerRepo, defaultBranch) {
+function makeConfig(pm, ownerRepo, defaultBranch2) {
   return {
     $schema: "https://raw.githubusercontent.com/aharonyaircohen/kody-engine/main/kody.config.schema.json",
     quality: qualityCommandsFor(pm),
-    git: { defaultBranch },
+    git: { defaultBranch: defaultBranch2 },
     github: {
       owner: ownerRepo?.owner ?? "OWNER",
       repo: ownerRepo?.repo ?? "REPO"
@@ -7075,12 +7136,12 @@ function performInit(cwd, force) {
   const skipped = [];
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
-  const defaultBranch = defaultBranchFromGit(cwd);
+  const defaultBranch2 = defaultBranchFromGit(cwd);
   const configPath = path23.join(cwd, "kody.config.json");
   if (fs24.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
-    const cfg = makeConfig(pm, ownerRepo, defaultBranch);
+    const cfg = makeConfig(pm, ownerRepo, defaultBranch2);
     fs24.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
@@ -8790,19 +8851,8 @@ var runFlow = async (ctx) => {
     process.stderr.write(`[kody runFlow] resolved base branch: ${base} (from --base)
 `);
   }
-  try {
-    const branchInfo = ensureFeatureBranch(issueNumber, issue.title, ctx.config.git.defaultBranch, ctx.cwd, base ?? void 0);
-    ctx.data.branch = branchInfo.branch;
-  } catch (err) {
-    if (err instanceof UncommittedChangesError) {
-      ctx.output.exitCode = 5;
-      ctx.output.reason = err.message;
-      ctx.skipAgent = true;
-      tryPost(issueNumber, `\u26A0\uFE0F kody refused to start: ${err.message}`, ctx.cwd);
-      return;
-    }
-    throw err;
-  }
+  const branchInfo = ensureFeatureBranch(issueNumber, issue.title, ctx.config.git.defaultBranch, ctx.cwd, base ?? void 0);
+  ctx.data.branch = branchInfo.branch;
   const runUrl = getRunUrl();
   const startMsg = runUrl ? `\u2699\uFE0F kody started \u2014 branch \`${ctx.data.branch}\`, run ${runUrl}` : `\u2699\uFE0F kody started \u2014 branch \`${ctx.data.branch}\``;
   tryPost(issueNumber, startMsg, ctx.cwd);
@@ -8954,8 +9004,23 @@ function buildChildEnv(parent, force) {
 
 // src/scripts/serveFlow.ts
 import { spawn as spawn3 } from "child_process";
+function parseTarget(positional) {
+  if (!Array.isArray(positional) || positional.length === 0) return "none";
+  const first = String(positional[0]).toLowerCase();
+  if (first === "vscode" || first === "code") return "vscode";
+  if (first === "claude") return "claude";
+  throw new Error(`unknown serve subcommand: "${positional[0]}" (expected: vscode, claude, or omit)`);
+}
+function buildProxyEnv(url) {
+  return {
+    ...process.env,
+    ANTHROPIC_BASE_URL: url,
+    ANTHROPIC_API_KEY: getAnthropicApiKeyOrDummy()
+  };
+}
 var serveFlow = async (ctx) => {
   ctx.skipAgent = true;
+  const target = parseTarget(ctx.args._);
   const model = parseProviderModel(ctx.config.agent.model);
   const usesProxy = needsLitellmProxy(model);
   let handle = null;
@@ -8970,19 +9035,45 @@ var serveFlow = async (ctx) => {
 `);
   }
   const url = handle?.url ?? LITELLM_DEFAULT_URL;
-  const noEditor = ctx.args.noEditor === true;
-  if (!noEditor) {
-    const env = { ...process.env };
-    if (usesProxy) {
-      env.ANTHROPIC_BASE_URL = url;
-      env.ANTHROPIC_API_KEY = getAnthropicApiKeyOrDummy();
+  const editorEnv = usesProxy ? buildProxyEnv(url) : { ...process.env };
+  const killProxy = () => {
+    if (handle) {
+      process.stdout.write(`[kody serve] stopping LiteLLM proxy...
+`);
+      try {
+        handle.kill();
+      } catch {
+      }
     }
+  };
+  if (target === "claude") {
+    process.stdout.write(`[kody serve] launching Claude Code at ${ctx.cwd}
+`);
+    if (usesProxy) process.stdout.write(`  ANTHROPIC_BASE_URL=${url}
+`);
+    const args = ["--dangerously-skip-permissions", "--model", model.model];
+    const child = spawn3("claude", args, { stdio: "inherit", env: editorEnv, cwd: ctx.cwd });
+    const exitCode = await new Promise((resolve4) => {
+      child.on("exit", (code) => resolve4(code ?? 0));
+      child.on("error", (err) => {
+        process.stderr.write(`[kody serve] failed to launch Claude Code: ${err.message}
+`);
+        process.stderr.write(`  Install: https://docs.anthropic.com/claude/docs/claude-code
+`);
+        resolve4(1);
+      });
+    });
+    killProxy();
+    ctx.output.exitCode = exitCode;
+    return;
+  }
+  if (target === "vscode") {
     process.stdout.write(`[kody serve] launching VS Code at ${ctx.cwd}
 `);
     if (usesProxy) process.stdout.write(`  ANTHROPIC_BASE_URL=${url}
 `);
     try {
-      const code = spawn3("code", [ctx.cwd], { stdio: "inherit", env, detached: true });
+      const code = spawn3("code", [ctx.cwd], { stdio: "inherit", env: editorEnv, detached: true });
       code.on("error", (err) => {
         process.stderr.write(`[kody serve] failed to launch VS Code: ${err.message}
 `);
@@ -9000,20 +9091,15 @@ var serveFlow = async (ctx) => {
 `);
   const keepAlive = setInterval(() => {
   }, 6e4);
-  const cleanup = (signal, exitCode) => {
+  const shutdown = (signal, exitCode) => {
     clearInterval(keepAlive);
-    if (handle) {
-      process.stdout.write(`[kody serve] received ${signal}, stopping LiteLLM proxy...
+    process.stdout.write(`[kody serve] received ${signal}
 `);
-      try {
-        handle.kill();
-      } catch {
-      }
-    }
+    killProxy();
     process.exit(exitCode);
   };
-  process.on("SIGINT", () => cleanup("SIGINT", 130));
-  process.on("SIGTERM", () => cleanup("SIGTERM", 143));
+  process.on("SIGINT", () => shutdown("SIGINT", 130));
+  process.on("SIGTERM", () => shutdown("SIGTERM", 143));
   await new Promise(() => {
   });
 };
@@ -10235,6 +10321,9 @@ function validateInputs(specs, raw) {
       throw new Error(`unknown arg: --${key}`);
     }
   }
+  if (Array.isArray(raw._)) {
+    out._ = raw._;
+  }
   for (const spec of specs) {
     const v = raw[spec.name];
     if (v === void 0 || v === null) continue;
@@ -10475,7 +10564,7 @@ async function runContainerLoop(profile, ctx, input) {
     process.stderr.write(`[kody container] step ${iteration}: invoking ${child.exec}
 `);
     if (profile.resetBetweenChildren !== false) {
-      resetWorkingTree(input.cwd);
+      resetWorkingTree2(input.cwd);
     } else {
       process.stderr.write(`[kody container] resetBetweenChildren=false; preserving tracked tree
 `);
@@ -10638,7 +10727,7 @@ async function runContainerLoop(profile, ctx, input) {
     currentIdx = nextIdx;
   }
 }
-function resetWorkingTree(cwd) {
+function resetWorkingTree2(cwd) {
   try {
     execFileSync29("git", ["reset", "--hard", "HEAD"], {
       cwd,
@@ -10734,7 +10823,6 @@ Exit codes (inherited from kody run):
   2   verify failed (no PR opened \u2014 branch pushed for inspection)
   3   no commits to ship
   4   PR creation failed
-  5   uncommitted changes on target branch
   99  wrapper crashed
 `;
 function parseCiArgs(argv) {
@@ -11538,7 +11626,6 @@ Exit codes:
   2   verify failed (no PR opened \u2014 branch pushed for inspection) \u2014 skipped in resolve mode
   3   no commits to ship (also the resolve clean-merge short-circuit)
   4   PR creation failed
-  5   uncommitted changes on target branch
   64  invalid CLI args
   99  wrapper crashed
 `;

package/dist/executables/serve/profile.json

@@ -1,16 +1,8 @@
 {
   "name": "serve",
   "role": "utility",
-  "describe": "Start a LiteLLM proxy and launch VS Code with ANTHROPIC_BASE_URL pointed at it. Long-lived — Ctrl+C to stop.",
-  "inputs": [
-    {
-      "name": "noEditor",
-      "flag": "--no-editor",
-      "type": "bool",
-      "required": false,
-      "describe": "Run the LiteLLM proxy only; do not launch VS Code."
-    }
-  ],
+  "describe": "Start a LiteLLM proxy and optionally launch an editor pointed at it. Usage: `kody serve` (proxy only), `kody serve vscode`, `kody serve claude`. Long-lived — Ctrl+C to stop.",
+  "inputs": [],
   "claudeCode": {
     "model": "inherit",
     "permissionMode": "acceptEdits",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.70",
+  "version": "0.4.72",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,23 @@
     "templates",
     "kody.config.schema.json"
   ],
+  "scripts": {
+    "kody": "tsx bin/kody.ts",
+    "serve": "tsx bin/kody.ts serve",
+    "serve:vscode": "tsx bin/kody.ts serve vscode",
+    "serve:claude": "tsx bin/kody.ts serve claude",
+    "build": "tsup && node scripts/copy-assets.cjs",
+    "check:modularity": "tsx scripts/check-script-modularity.ts",
+    "pretest": "pnpm check:modularity",
+    "test": "vitest run tests/unit tests/int --no-coverage",
+    "test:e2e": "vitest run tests/e2e --no-coverage",
+    "test:all": "vitest run tests --no-coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "format": "biome format --write",
+    "prepublishOnly": "pnpm build"
+  },
   "dependencies": {
     "@actions/cache": "^6.0.0",
     "@anthropic-ai/claude-agent-sdk": "0.2.119",
@@ -33,19 +50,5 @@
     "url": "git+https://github.com/aharonyaircohen/kody-engine.git"
   },
   "homepage": "https://github.com/aharonyaircohen/kody-engine",
-  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues",
-  "scripts": {
-    "kody": "tsx bin/kody.ts",
-    "serve": "tsx bin/kody.ts serve",
-    "build": "tsup && node scripts/copy-assets.cjs",
-    "check:modularity": "tsx scripts/check-script-modularity.ts",
-    "pretest": "pnpm check:modularity",
-    "test": "vitest run tests/unit tests/int --no-coverage",
-    "test:e2e": "vitest run tests/e2e --no-coverage",
-    "test:all": "vitest run tests --no-coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check",
-    "lint:fix": "biome check --write",
-    "format": "biome format --write"
-  }
-}
+  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues"
+}