@kody-ade/kody-engine-lite 0.1.27 → 0.1.29

package/README.md

@@ -2,24 +2,93 @@
 
 **Issue → PR in one command.** Comment `@kody` on a GitHub issue and Kody autonomously classifies, plans, builds, tests, reviews, fixes, and ships a pull request.
 
+Kody is a 7-stage autonomous SDLC pipeline that runs in GitHub Actions. It uses Claude Code (or any LLM via LiteLLM) to turn issues into production-ready PRs — with quality gates, AI-powered failure diagnosis, risk-based human approval, and self-improving memory.
+
+## Pipeline
+
 ```
-@kody  →  taskify → plan → build → verify → review → fix → ship  →  PR created
+                        ┌─────────────────────────────────────────────────────────┐
+                        │                    @kody on issue                        │
+                        └────────────────────────┬────────────────────────────────┘
+                                                 │
+                        ┌────────────────────────▼────────────────────────────────┐
+                        │  ① TASKIFY                                              │
+                        │  Classify task, detect complexity, ask questions         │
+                        │  Model: haiku │ Output: task.json                       │
+                        └────────────────────────┬────────────────────────────────┘
+                                                 │
+                                    ┌────────────▼────────────┐
+                                    │  LOW?  skip to ④        │
+                                    │  MEDIUM?  continue      │
+                                    │  HIGH?  continue        │
+                                    └────────────┬────────────┘
+                                                 │
+                        ┌────────────────────────▼────────────────────────────────┐
+                        │  ② PLAN                                                 │
+                        │  TDD implementation plan (deep reasoning)               │
+                        │  Model: opus │ Output: plan.md                          │
+                        └────────────────────────┬────────────────────────────────┘
+                                                 │
+                                    ┌────────────▼────────────┐
+                                    │  HIGH risk?             │
+                                    │  🛑 Pause for approval  │──── @kody approve
+                                    └────────────┬────────────┘
+                                                 │
+                        ┌────────────────────────▼────────────────────────────────┐
+                        │  ③ BUILD                                                │
+                        │  Implement code via Claude Code tools                   │
+                        │  Model: sonnet │ Output: code changes + git commit      │
+                        └────────────────────────┬────────────────────────────────┘
+                                                 │
+                        ┌────────────────────────▼────────────────────────────────┐
+                        │  ④ VERIFY                                               │
+                        │  typecheck + tests + lint                               │
+                        │  ┌──────────────────────────────────────────────┐       │
+                        │  │  Fail? → AI diagnosis → autofix → retry ×2  │       │
+                        │  └──────────────────────────────────────────────┘       │
+                        └────────────────────────┬────────────────────────────────┘
+                                                 │
+                        ┌────────────────────────▼────────────────────────────────┐
+                        │  ⑤ REVIEW                                               │
+                        │  Code review: PASS/FAIL + Critical/Major/Minor          │
+                        │  Model: opus │ Output: review.md                        │
+                        └────────────────────────┬────────────────────────────────┘
+                                                 │
+                        ┌────────────────────────▼────────────────────────────────┐
+                        │  ⑥ REVIEW-FIX                                           │
+                        │  Fix Critical and Major findings                        │
+                        │  Model: sonnet │ Output: code changes + git commit      │
+                        └────────────────────────┬────────────────────────────────┘
+                                                 │
+                        ┌────────────────────────▼────────────────────────────────┐
+                        │  ⑦ SHIP                                                 │
+                        │  Push branch + create PR with Closes #N                 │
+                        │  Output: ship.md + PR link                              │
+                        └────────────────────────┬────────────────────────────────┘
+                                                 │
+                        ┌────────────────────────▼────────────────────────────────┐
+                        │                ✅ PR created & ready for review          │
+                        └─────────────────────────────────────────────────────────┘
 ```
 
-Kody is a 7-stage autonomous SDLC pipeline that runs in GitHub Actions. It uses Claude Code (or any LLM via LiteLLM) to turn issues into production-ready PRs — with quality gates, AI-powered failure diagnosis, risk-based human approval, and self-improving memory.
+Each stage runs in a **fresh context window** with **accumulated context** from previous stages — so complex tasks (auth systems, CRUD features, API clients) don't lose track of earlier decisions.
+
+[Pipeline details →](docs/PIPELINE.md)
 
 ## Why Kody?
 
-Most AI coding tools are **autocomplete** (Copilot) or **chat-based** (Cursor, Cline). You still drive. Kody is different: it's an **autonomous pipeline** that takes an issue and delivers a tested, reviewed PR.
+Most AI coding tools are **autocomplete** (Copilot) or **chat-based** (Cursor, Cline). You still drive. Kody is different: it's an **autonomous pipeline** that takes an issue and delivers a tested, reviewed PR — even for complex, multi-file features that single-agent tools choke on.
 
 | | Kody | Copilot Workspace | Devin | Cursor Agent |
 |---|---|---|---|---|
 | **Runs in CI** | GitHub Actions | GitHub Cloud | Devin Cloud | Local IDE |
 | **Fire and forget** | Comment `@kody`, walk away | Must interact | Must interact | Must be open |
 | **Quality gates** | typecheck + tests + lint + AI diagnosis + auto-retry | Basic | Runs tests | Runs tests |
-| **Risk gate** | Pauses HIGH-risk tasks for human approval | No | No | No |
+| **Risk gate** | Pauses HIGH-risk for human approval | No | No | No |
 | **Model flexible** | Any LLM via LiteLLM | GitHub models only | Proprietary | Cursor models |
 | **Open source** | MIT | Proprietary | Proprietary | Proprietary |
+| **Accumulated context** | Curated context flows between stages | Single bloated conversation | Single agent | Single agent |
+| **Complex tasks** | Full auth system: 7 stages + 3 autofix retries | Struggles with large scope | Better | Struggles with large scope |
 | **Cost** | Your API costs only | $10-39/month | $20-500/month | Subscription |
 
 [Full comparison →](docs/COMPARISON.md)
@@ -30,48 +99,22 @@ Most AI coding tools are **autocomplete** (Copilot) or **chat-based** (Cursor, C
 # 1. Install
 npm install -g @kody-ade/kody-engine-lite
 
-# 2. Initialize (auto-detects everything)
-cd your-project
-kody-engine-lite init
-
-# 3. Set up GitHub
+# 2. Set up GitHub secret
 gh secret set ANTHROPIC_API_KEY --repo owner/repo
 # Settings → Actions → "Allow GitHub Actions to create and approve pull requests"
 
-# 4. Push
-git add .github/workflows/kody.yml kody.config.json .kody/
-git commit -m "chore: add kody engine"
-git push
+# 3. Initialize (auto-detects, commits, and pushes)
+cd your-project
+kody-engine-lite init
 
-# 5. Comment on any issue
+# 4. Comment on any issue
 @kody
 ```
 
-`init` spawns Claude Code to analyze your project and generates: workflow file, config with auto-detected quality commands, project memory (architecture + conventions), and 14 GitHub labels.
+`init` spawns Claude Code to analyze your project and generates: workflow file, config with auto-detected quality commands, project memory (architecture + conventions), 14 GitHub labels — then commits and pushes everything.
 
 **Prerequisites:** Node.js >= 22, [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code), [GitHub CLI](https://cli.github.com/), git
 
-## Pipeline
-
-```
-@kody on issue
-  ↓
-1. taskify   — classify task, detect complexity, ask questions     → task.json
-2. plan      — TDD implementation plan (deep reasoning)           → plan.md
-   ↓ HIGH risk? pause for human approval
-3. build     — implement code via Claude Code tools                → code changes
-4. verify    — typecheck + tests + lint (AI diagnosis + autofix)   → verify.md
-5. review    — code review: PASS/FAIL + Critical/Major/Minor      → review.md
-6. review-fix — fix Critical and Major findings                    → code changes
-7. ship      — push branch + create PR with Closes #N             → ship.md
-  ↓
-PR created
-```
-
-Complexity auto-detected: **low** skips plan/review (4 stages), **medium** skips review-fix (6 stages), **high** runs all 7.
-
-[Pipeline details →](docs/PIPELINE.md)
-
 ## Commands
 
 ### GitHub Comments
@@ -99,6 +142,7 @@ kody-engine-lite init [--force]
 - **Risk Gate** — HIGH-risk tasks pause for human plan approval before building ([details](docs/FEATURES.md#risk-gate))
 - **AI Failure Diagnosis** — classifies errors as fixable/infrastructure/pre-existing/abort before retry ([details](docs/FEATURES.md#ai-powered-failure-diagnosis))
 - **Question Gates** — asks product/architecture questions when the task is unclear ([details](docs/FEATURES.md#question-gates))
+- **Accumulated Context** — each stage passes curated context to the next — fresh window, shared knowledge ([details](docs/FEATURES.md#accumulated-context))
 - **Retrospective** — analyzes each run, identifies patterns, suggests improvements ([details](docs/FEATURES.md#retrospective-system))
 - **Auto-Learning** — extracts coding conventions from each successful run ([details](docs/FEATURES.md#auto-learning-memory))
 - **Any LLM** — route through LiteLLM to use MiniMax, GPT, Gemini, local models ([setup guide](docs/LITELLM.md))
@@ -107,7 +151,7 @@ kody-engine-lite init [--force]
 
 | Doc | What's in it |
 |-----|-------------|
-| [Pipeline](docs/PIPELINE.md) | Stage details, complexity skipping, artifacts, state machine |
+| [Pipeline](docs/PIPELINE.md) | Stage details, complexity skipping, accumulated context, artifacts |
 | [Features](docs/FEATURES.md) | Risk gate, diagnosis, retrospective, auto-learn, labels |
 | [LiteLLM](docs/LITELLM.md) | Non-Anthropic model setup, auto-start, tested providers |
 | [Configuration](docs/CONFIGURATION.md) | Full config reference, env vars, workflow setup |

package/dist/bin/cli.js

@@ -87,20 +87,22 @@ function checkCommand(command2, args2) {
 function createClaudeCodeRunner() {
   return {
     async run(_stageName, prompt, model, timeout, _taskDir, options) {
-      return runSubprocess(
-        "claude",
-        [
-          "--print",
-          "--model",
-          model,
-          "--dangerously-skip-permissions",
-          "--allowedTools",
-          "Bash,Edit,Read,Write,Glob,Grep"
-        ],
-        prompt,
-        timeout,
-        options
-      );
+      const args2 = [
+        "--print",
+        "--model",
+        model,
+        "--dangerously-skip-permissions",
+        "--allowedTools",
+        "Bash,Edit,Read,Write,Glob,Grep"
+      ];
+      if (options?.sessionId) {
+        if (options.resumeSession) {
+          args2.push("--resume", options.sessionId);
+        } else {
+          args2.push("--session-id", options.sessionId);
+        }
+      }
+      return runSubprocess("claude", args2, prompt, timeout, options);
     },
     async healthCheck() {
       return checkCommand("claude", ["--version"]);
@@ -824,6 +826,17 @@ var init_runner_selection = __esm({
 // src/stages/agent.ts
 import * as fs5 from "fs";
 import * as path5 from "path";
+function getSessionInfo(stageName, sessions) {
+  const group = SESSION_GROUP[stageName];
+  if (!group) return void 0;
+  const existing = sessions[group];
+  if (existing) {
+    return { sessionId: existing, resumeSession: true };
+  }
+  const newId = crypto.randomUUID();
+  sessions[group] = newId;
+  return { sessionId: newId, resumeSession: false };
+}
 function validateStageOutput(stageName, content) {
   switch (stageName) {
     case "taskify":
@@ -850,10 +863,16 @@ async function executeAgentStage(ctx, def) {
   if (config.agent.litellmUrl) {
     extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
   }
+  const sessions = ctx.sessions ?? {};
+  const sessionInfo = getSessionInfo(def.name, sessions);
+  if (sessionInfo) {
+    logger.info(`  session: ${SESSION_GROUP[def.name]} (${sessionInfo.resumeSession ? "resume" : "new"})`);
+  }
   const runner = getRunnerForStage(ctx, def.name);
   const result = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
     cwd: ctx.projectDir,
-    env: extraEnv
+    env: extraEnv,
+    ...sessionInfo
   });
   if (result.outcome !== "completed") {
     return { outcome: result.outcome, error: result.error, retries: 0 };
@@ -924,6 +943,7 @@ ${summary}
 `;
   fs5.appendFileSync(contextPath, entry);
 }
+var SESSION_GROUP;
 var init_agent = __esm({
   "src/stages/agent.ts"() {
     "use strict";
@@ -932,6 +952,14 @@ var init_agent = __esm({
     init_config();
     init_runner_selection();
     init_logger();
+    SESSION_GROUP = {
+      taskify: "explore",
+      plan: "explore",
+      build: "build",
+      autofix: "build",
+      "review-fix": "build",
+      review: "review"
+    };
   }
 });
 
@@ -2072,6 +2100,7 @@ async function runPipelineInner(ctx) {
     state = initState(ctx.taskId);
     writeState(state, ctx.taskDir);
   }
+  ctx.sessions = state.sessions ?? {};
   if (state.state !== "running") {
     state.state = "running";
     for (const stage of STAGES) {
@@ -2159,6 +2188,7 @@ async function runPipelineInner(ctx) {
         error: isTimeout ? "Stage timed out" : result.error ?? "Stage failed"
       };
       state.state = "failed";
+      state.sessions = ctx.sessions;
       writeState(state, ctx.taskDir);
       logger.error(`[${def.name}] ${isTimeout ? "\u23F1 timed out" : `\u2717 failed: ${result.error}`}`);
       if (ctx.input.issueNumber && !ctx.input.local) {
@@ -2166,6 +2196,7 @@ async function runPipelineInner(ctx) {
       }
       break;
     }
+    state.sessions = ctx.sessions;
     writeState(state, ctx.taskDir);
   }
   const allCompleted = STAGES.every((s) => state.stages[s.name].state === "completed");
@@ -3307,12 +3338,39 @@ ${archItems.join("\n")}
     fs19.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }
+  console.log("\n\u2500\u2500 Git \u2500\u2500");
+  const filesToCommit = [
+    ".github/workflows/kody.yml",
+    "kody.config.json",
+    ".kody/memory/architecture.md",
+    ".kody/memory/conventions.md"
+  ].filter((f) => fs19.existsSync(path18.join(cwd, f)));
+  if (filesToCommit.length > 0) {
+    try {
+      execFileSync11("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+      const staged = execFileSync11("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+      if (staged) {
+        execFileSync11("git", ["commit", "--no-gpg-sign", "-m", "chore: add kody engine"], { cwd, stdio: "pipe" });
+        console.log(`  \u2713 Committed: ${filesToCommit.join(", ")}`);
+        try {
+          execFileSync11("git", ["push"], { cwd, stdio: "pipe", timeout: 3e4 });
+          console.log("  \u2713 Pushed to origin");
+        } catch {
+          console.log("  \u25CB Push failed \u2014 run 'git push' manually");
+        }
+      } else {
+        console.log("  \u25CB No new changes to commit");
+      }
+    } catch (err) {
+      console.log(`  \u25CB Git commit skipped: ${err instanceof Error ? err.message : err}`);
+    }
+  }
   const allChecks = [...checks, ghAuth, ghRepo];
   const failed = allChecks.filter((c) => !c.ok);
   console.log("\n\u2500\u2500 Summary \u2500\u2500");
   if (failed.length === 0) {
     console.log("  \u2713 All checks passed! Ready to use.");
-    console.log("\n  Next: Comment '@kody full <task-id>' on a GitHub issue");
+    console.log("\n  Next: Comment '@kody' on a GitHub issue");
   } else {
     console.log(`  \u26A0 ${failed.length} issue(s) to fix:`);
     for (const c of failed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",