jeo-code 0.1.0 → 0.4.5

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "jeo-code",
-  "version": "0.1.0",
+  "version": "0.4.5",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",
   "bin": {
-    "joc": "src/cli.ts"
+    "jeo": "src/cli.ts"
   },
   "files": [
     "src",
     "scripts/install.sh",
     "scripts/uninstall.sh",
     "tsconfig.json",
-    "README.md"
+    "README.md",
+    "README.ko.md",
+    "README.ja.md",
+    "README.zh.md"
   ],
   "engines": {
     "bun": ">=1.3.14"
@@ -31,7 +34,7 @@
     "bun",
     "cli",
     "spec-first",
-    "gjc"
+    "jeo"
   ],
   "publishConfig": {
     "access": "public",
@@ -41,14 +44,16 @@
   "scripts": {
     "start": "bun src/cli.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "build": "bun build src/cli.ts --compile --outfile dist/joc",
+    "build": "bun build src/cli.ts --compile --outfile dist/jeo",
     "pack:check": "npm pack --dry-run",
     "publish:npm": "npm publish --access public --registry https://registry.npmjs.org/",
+    "changelog:sync": "bun scripts/sync-changelog.ts",
     "test": "bun test"
   },
   "dependencies": {
     "zod": "^3.24.1",
-    "chalk": "^5.3.0"
+    "chalk": "^5.3.0",
+    "js-tiktoken": "^1.0.21"
   },
   "devDependencies": {
     "@types/bun": "^1.1.14",

package/scripts/install.sh

@@ -1,5 +1,5 @@
 #!/bin/sh
-# joc (jeo-code) installer — gjc-style bun global install.
+# jeo (jeo-code) installer — gjc-style bun global install.
 #
 # The gjc parity path is a single Bun global install. The published-package form
 # (once jeo-code is on npm) is identical to gajae-code's:
@@ -25,25 +25,25 @@
 set -e
 
 DEFAULT_REPO="https://github.com/akillness/jeo-code.git"
-REPO="${JOC_REPO:-${JOC_REPO_URL:-$DEFAULT_REPO}}"
-PKG="${JOC_PKG:-jeo-code}"
-INSTALL_DIR="${JOC_INSTALL_DIR:-$HOME/.local/bin}"
+REPO="${JEO_REPO:-${JEO_REPO:-${JEO_REPO_URL:-${JEO_REPO_URL:-$DEFAULT_REPO}}}}"
+PKG="${JEO_PKG:-${JEO_PKG:-jeo-code}}"
+INSTALL_DIR="${JEO_INSTALL_DIR:-${JEO_INSTALL_DIR:-$HOME/.local/bin}}"
 MIN_BUN_VERSION="1.3.14"
 
 MODE="global"
 REF=""
 SRC_DIR=""
 LINKED=""
-REGISTRY="${JOC_REGISTRY:-}"
-SCOPE="${JOC_REGISTRY_SCOPE:-}"
+REGISTRY="${JEO_REGISTRY:-${JEO_REGISTRY:-}}"
+SCOPE="${JEO_REGISTRY_SCOPE:-${JEO_REGISTRY_SCOPE:-}}"
 PERSIST_REGISTRY=0
 PROJECT_NPMRC=0
 DRY_RUN=0
 
 usage() {
   cat <<EOF
-joc installer (gjc-style Bun global install)
-  (default)            bun global install from $REPO  →  exposes 'joc'
+jeo installer (gjc-style Bun global install)
+  (default)            bun global install from $REPO  →  exposes 'jeo'
   --repo <url|owner/repo>  git source (default $DEFAULT_REPO)
   --npm                bun install -g $PKG (npm registry; gjc parity once published)
   --package <name>     npm package name for --npm (default $PKG)
@@ -58,11 +58,11 @@ joc installer (gjc-style Bun global install)
   --ref <ref>          install a specific tag/branch/commit
   --dry-run            print the bun/npm commands without installing
 Environment:
-  JOC_INSTALL_DIR      (default \$HOME/.local/bin — compatibility symlink)
-  JOC_REPO/JOC_REPO_URL(default $DEFAULT_REPO)
-  JOC_PKG             (default $PKG)
-  JOC_REGISTRY        one-shot or persisted registry URL
-  JOC_REGISTRY_SCOPE  optional scope such as @my-org
+  JEO_INSTALL_DIR      (default \$HOME/.local/bin — compatibility symlink; legacy JEO_* names still honored)
+  JEO_REPO/JEO_REPO_URL(default $DEFAULT_REPO)
+  JEO_PKG             (default $PKG)
+  JEO_REGISTRY        one-shot or persisted registry URL
+  JEO_REGISTRY_SCOPE  optional scope such as @my-org
 EOF
 }
 
@@ -225,8 +225,8 @@ run_bun_global_add() {
   fi
 }
 
-# Bun global install (the gjc-idiomatic path). Exposes the package's `joc` bin
-# in Bun's global bin dir (~/.bun/bin/joc).
+# Bun global install (the gjc-idiomatic path). Exposes the package's `jeo` bin
+# in Bun's global bin dir (~/.bun/bin/jeo).
 install_global() {
   spec=$(normalize_repo_spec "$REPO")
   echo "Installing $PKG globally via Bun ($spec)..."
@@ -267,26 +267,26 @@ install_binary() {
   fi
   if [ "$DRY_RUN" = "1" ]; then
     echo "+ ( cd $SRC_DIR && bun install --silent )"
-    echo "+ bun build src/cli.ts --compile --outfile $INSTALL_DIR/joc"
+    echo "+ bun build src/cli.ts --compile --outfile $INSTALL_DIR/jeo"
   else
     ( cd "$SRC_DIR" && bun install --silent >/dev/null )
     mkdir -p "$INSTALL_DIR"
-    echo "Compiling standalone binary → $INSTALL_DIR/joc ..."
-    ( cd "$SRC_DIR" && bun build src/cli.ts --compile --outfile "$INSTALL_DIR/joc" >/dev/null )
-    chmod +x "$INSTALL_DIR/joc" 2>/dev/null || true
+    echo "Compiling standalone binary → $INSTALL_DIR/jeo ..."
+    ( cd "$SRC_DIR" && bun build src/cli.ts --compile --outfile "$INSTALL_DIR/jeo" >/dev/null )
+    chmod +x "$INSTALL_DIR/jeo" 2>/dev/null || true
   fi
 }
 
-# Add a compatibility symlink in INSTALL_DIR so the documented location keeps
-# working even when Bun's global bin dir is not on PATH.
+# Add a symlink in INSTALL_DIR so the documented location works even when
+# Bun's global bin dir is not on PATH.
 link_compat() {
   [ "$DRY_RUN" = "1" ] && return 0
   BUN_BIN="$(bun_bin_dir)"
-  [ -e "$BUN_BIN/joc" ] && LINKED="$BUN_BIN/joc"
+  [ -e "$BUN_BIN/jeo" ] && LINKED="$BUN_BIN/jeo"
   mkdir -p "$INSTALL_DIR"
   if [ -n "$LINKED" ]; then
-    ln -sf "$LINKED" "$INSTALL_DIR/joc"
-    chmod +x "$INSTALL_DIR/joc" 2>/dev/null || true
+    ln -sf "$LINKED" "$INSTALL_DIR/jeo"
+    chmod +x "$INSTALL_DIR/jeo" 2>/dev/null || true
   fi
 }
 
@@ -297,11 +297,11 @@ print_done() {
     echo "Dry run complete; no install changes were made."
     return 0
   fi
-  [ -n "$LINKED" ] && echo "Linked joc via Bun → $LINKED"
-  [ -e "$INSTALL_DIR/joc" ] && echo "Compatibility symlink → $INSTALL_DIR/joc"
+  [ -n "$LINKED" ] && echo "Linked jeo via Bun → $LINKED"
+  [ -e "$INSTALL_DIR/jeo" ] && echo "Compatibility symlink → $INSTALL_DIR/jeo"
   case ":$PATH:" in
-    *":$BUN_BIN:"*|*":$INSTALL_DIR:"*) echo "Run: joc --help" ;;
-    *) echo "Add $BUN_BIN (or $INSTALL_DIR) to PATH, then run: joc --help" ;;
+    *":$BUN_BIN:"*|*":$INSTALL_DIR:"*) echo "Run: jeo --help" ;;
+    *) echo "Add $BUN_BIN (or $INSTALL_DIR) to PATH, then run: jeo --help" ;;
   esac
 }
 

package/scripts/uninstall.sh

@@ -1,30 +1,32 @@
 #!/bin/sh
-# joc uninstaller — removes binary symlink and optionally global config.
+# jeo uninstaller — removes binary symlink and optionally global config.
 # Usage:
 #   sh scripts/uninstall.sh              # remove binary only
-#   sh scripts/uninstall.sh --purge      # also remove ~/.joc/
+#   sh scripts/uninstall.sh --purge      # also remove ~/.jeo/
 set -e
-INSTALL_DIR="${JOC_INSTALL_DIR:-$HOME/.local/bin}"
+INSTALL_DIR="${JEO_INSTALL_DIR:-$HOME/.local/bin}"
 PURGE=0
 [ "$1" = "--purge" ] && PURGE=1
 
-if [ -L "$INSTALL_DIR/joc" ] || [ -f "$INSTALL_DIR/joc" ]; then
-  rm -f "$INSTALL_DIR/joc"
-  echo "Removed $INSTALL_DIR/joc"
-else
-  echo "No joc binary at $INSTALL_DIR/joc"
-fi
+for BIN_NAME in jeo; do
+  if [ -L "$INSTALL_DIR/$BIN_NAME" ] || [ -f "$INSTALL_DIR/$BIN_NAME" ]; then
+    rm -f "$INSTALL_DIR/$BIN_NAME"
+    echo "Removed $INSTALL_DIR/$BIN_NAME"
+  fi
+done
 
 # Remove the bun-native link (bin + global registry entry).
 BUN_BIN="${BUN_INSTALL:-$HOME/.bun}/bin"
-if [ -L "$BUN_BIN/joc" ] || [ -f "$BUN_BIN/joc" ]; then
-  rm -f "$BUN_BIN/joc"
-  echo "Removed $BUN_BIN/joc (bun link)"
-fi
+for BIN_NAME in jeo; do
+  if [ -L "$BUN_BIN/$BIN_NAME" ] || [ -f "$BUN_BIN/$BIN_NAME" ]; then
+    rm -f "$BUN_BIN/$BIN_NAME"
+    echo "Removed $BUN_BIN/$BIN_NAME (bun link)"
+  fi
+done
 GLOBAL_PKG="${BUN_INSTALL:-$HOME/.bun}/install/global/node_modules/jeo-code"
 [ -e "$GLOBAL_PKG" ] && rm -rf "$GLOBAL_PKG" && echo "Unregistered jeo-code from bun global"
 
 if [ "$PURGE" = "1" ]; then
-  rm -rf "$HOME/.joc"
-  echo "Removed ~/.joc/"
+  rm -rf "$HOME/.jeo"
+  echo "Removed ~/.jeo/"
 fi

package/src/AGENTS.md

@@ -0,0 +1,50 @@
+<!-- Parent: ../AGENTS.md -->
+<!-- Generated: 2026-06-11 | Updated: 2026-06-11 -->
+
+# src
+
+## Purpose
+Core application source code for the `jeo-code` CLI and agent runtime. It orchestrates user commands, TUI rendering, agent intelligence, tool execution, and workspace integrations.
+
+## Key Files
+| File | Description |
+|------|-------------|
+| `cli.ts` | The main binary entrypoint |
+| `index.ts` | Library exports |
+| `bun-imports.d.ts` / `md-modules.d.ts` | TypeScript declarations for Bun built-ins and raw module imports |
+
+## Subdirectories
+| Directory | Purpose |
+|-----------|---------|
+| `agent/` | Agent execution loop, tool registry, session state, and subagent management (see `agent/AGENTS.md`) |
+| `ai/` | LLM client interactions, provider abstractions, and token management (see `ai/AGENTS.md`) |
+| `auth/` | OAuth flows and credential management (see `auth/AGENTS.md`) |
+| `cli/` | Command-line interface definitions and arg parsing (see `cli/AGENTS.md`) |
+| `commands/` | Implementations for all `jeo` subcommands (launch, setup, team, etc.) (see `commands/AGENTS.md`) |
+| `mcp/` | Model Context Protocol integration (see `mcp/AGENTS.md`) |
+| `prompts/` | Bundled system prompts and skills (see `prompts/AGENTS.md`) |
+| `skills/` | Skill execution framework and discovery (see `skills/AGENTS.md`) |
+| `tui/` | Terminal User Interface, layout, and rendering (see `tui/AGENTS.md`) |
+| `util/` | General utilities, retry logic, and update checking (see `util/AGENTS.md`) |
+
+## For AI Agents
+
+### Working In This Directory
+- Entrypoints reside here, but domain logic should be pushed into appropriate subdirectories.
+- Adhere strictly to the Bun execution environment (no Node.js-specific modules unless polyfilled by Bun).
+
+### Testing Requirements
+- Code touched here is highly central; verify with `bun test` and `bun run typecheck`.
+
+### Common Patterns
+- Fast startup: limit top-level imports that execute expensive initialization.
+
+## Dependencies
+
+### Internal
+- Depends heavily on all subdirectories (`agent`, `tui`, `ai`, etc.).
+
+### External
+- Bun runtime APIs.
+
+<!-- MANUAL: -->

package/src/agent/AGENTS.md

@@ -0,0 +1,49 @@
+<!-- Parent: ../AGENTS.md -->
+<!-- Generated: 2026-06-11 | Updated: 2026-06-11 -->
+
+# agent
+
+## Purpose
+The core runtime loop, tool registry, session management, and state persistence for the `jeo-code` agent.
+
+## Key Files
+| File | Description |
+|------|-------------|
+| `loop.ts` | The primary execution loop orchestrating model calls and tool execution |
+| `tools.ts` | Built-in tool definitions (bash, read, write, edit, etc.) |
+| `state.ts` | File-backed state and session persistence (`.jeo/state/`) |
+| `session.ts` | Session context building, compaction, and history management |
+| `plan.ts` | Subagent planning structures and validation |
+| `step-budget.ts` | gjc-style flexible step budgeting: progress-scored extensions, hard cap, fail-fast |
+| `subagents.ts` / `task-tool.ts` | Delegation mechanisms and background execution of task subagents |
+
+## Subdirectories
+| Directory | Purpose |
+|-----------|---------|
+| `dev/` | Developer-specific agent tooling and spec automation (see `dev/AGENTS.md`) |
+
+## For AI Agents
+
+### Working In This Directory
+- Modifications here affect the fundamental capabilities of the agent. Proceed with extreme caution.
+- Ensure state writes are atomic and safe for concurrent execution.
+- Tool schemas must remain strict and well-documented.
+
+### Testing Requirements
+- Extensive unit testing required. Use mock tools to test the loop logic without side effects.
+- Verify session compaction does not lose critical context.
+
+### Common Patterns
+- Tool results are fenced properly to prevent prompt injection.
+- The loop is decoupled from the UI (events are emitted to be consumed by the TUI).
+
+## Dependencies
+
+### Internal
+- `src/ai/` for model inference.
+- `src/tui/` consumes events emitted by the loop.
+
+### External
+- System APIs (fs, child_process) via Bun.
+
+<!-- MANUAL: -->

package/src/agent/bash-fixups.ts

@@ -0,0 +1,103 @@
+/**
+ * GJC Bash Command Fixups — conservative, INTENT-PRESERVING, off-by-default rewrites
+ * for common CLI mistakes. Every rule is a no-op unless it matches exactly, and no rule
+ * may change what the command observably does (only its form). Gated behind
+ * `JEO_BASH_FIXUPS=1` by the caller (bashTool); never altered by default.
+ *
+ * Rules that would CHANGE behavior (e.g. merging stderr into a pipe with `2>&1`, which
+ * adds new data to the matched stream) are intentionally NOT included — that is
+ * intent-inferring, not intent-preserving.
+ */
+
+/** Tokenize respecting single/double quotes (quotes kept in the token). */
+function tokenize(cmd: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let inDoubleQuote = false;
+  let inSingleQuote = false;
+  for (let i = 0; i < cmd.length; i++) {
+    const char = cmd[i];
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      current += char;
+    } else if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      current += char;
+    } else if (char === " " && !inDoubleQuote && !inSingleQuote) {
+      if (current) { tokens.push(current); current = ""; }
+    } else {
+      current += char;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+/** Apply intent-preserving, conservative fixups. Returns the (possibly) rewritten
+ *  command and the list of rule names applied (empty when nothing matched). */
+export function applyBashFixups(command: string): { command: string; applied: string[] } {
+  let currentCommand = command;
+  const applied: string[] = [];
+
+  // Rule 1: strip-trailing — `ls -la; ` → `ls -la` (drop one trailing `;` + surrounding ws).
+  {
+    let newCmd = currentCommand.trim();
+    if (newCmd.endsWith(";")) newCmd = newCmd.slice(0, -1).trim();
+    if (newCmd !== command) {
+      currentCommand = newCmd;
+      applied.push("strip-trailing");
+    }
+  }
+
+  // Rule 2: useless-cat — `cat file | grep PAT` → `grep PAT file`.
+  // SINGLE-STAGE ONLY: bail if the grep args carry a downstream pipe/compound operator
+  // (`| && || ;`), since appending the file after them would corrupt the pipeline
+  // (`cat f | grep x | head` must NOT become `grep x | head f`).
+  const uselessCatRegex = /^\s*cat\s+((?:'[^']*'|"[^"]*"|[^\s|]+))\s*\|\s*(grep|egrep|fgrep)\s+(.+)$/;
+  const catMatch = currentCommand.match(uselessCatRegex);
+  if (catMatch && !/[|&;]/.test(catMatch[3]!)) {
+    currentCommand = `${catMatch[2]} ${catMatch[3]} ${catMatch[1]}`;
+    applied.push("useless-cat");
+  }
+
+  // Rule 3: dev-null-merge — both streams discarded two ways → the canonical form.
+  // `cmd >/dev/null 2>/dev/null` / `cmd 2>/dev/null 1>/dev/null` → `cmd >/dev/null 2>&1`
+  // (behavior-identical: stdout AND stderr both go to /dev/null either way).
+  const devNull = /(?:^|\s)(?:1?>\s*\/dev\/null\s+2>\s*\/dev\/null|2>\s*\/dev\/null\s+1?>\s*\/dev\/null)\s*$/;
+  if (devNull.test(currentCommand)) {
+    currentCommand = currentCommand.replace(devNull, " >/dev/null 2>&1");
+    applied.push("dev-null-merge");
+  }
+
+  // Rule 4: collapse-dot-slash — `././bin/run` → `./bin/run`.
+  const dotSlashRegex = /^\s*(?:\.\/){2,}(.*)$/;
+  const dotSlashMatch = currentCommand.match(dotSlashRegex);
+  if (dotSlashMatch) {
+    const leadingSpaces = currentCommand.match(/^\s*/)?.[0] || "";
+    currentCommand = `${leadingSpaces}./${dotSlashMatch[1]}`;
+    applied.push("collapse-dot-slash");
+  }
+
+  // Rule 5: grep-r-default-path — recursive grep with no path → append ` .`.
+  // Matches both short `-r`/`-R` (in a bundled flag) and `--recursive`.
+  const tokens = tokenize(currentCommand);
+  if (tokens.length > 1 && tokens[0] === "grep") {
+    let hasRecursiveFlag = false;
+    const posArgs: string[] = [];
+    for (let i = 1; i < tokens.length; i++) {
+      const token = tokens[i]!;
+      if (token.startsWith("-")) {
+        if (token === "--recursive") hasRecursiveFlag = true;
+        else if (!token.startsWith("--") && /[rR]/.test(token)) hasRecursiveFlag = true;
+      } else {
+        posArgs.push(token);
+      }
+    }
+    if (hasRecursiveFlag && posArgs.length === 1) {
+      currentCommand = `${currentCommand} .`;
+      applied.push("grep-r-default-path");
+    }
+  }
+
+  return { command: currentCommand, applied };
+}