easy-coding-harness 0.1.7 → 0.2.1

package/templates/shared-hooks/inject-subagent-context.py

@@ -4,6 +4,8 @@ import os
 from pathlib import Path
 import sys
 
+from easy_coding_state import snapshot_state
+
 
 def configure_stdio() -> None:
     for stream in (sys.stdin, sys.stdout, sys.stderr):
@@ -28,15 +30,6 @@ def find_ec_root(start: Path) -> Path | None:
         current = current.parent
 
 
-def load_json(path: Path) -> dict | None:
-    if not path.exists():
-        return None
-    try:
-        return json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-
-
 def emit(event_name: str, context: str) -> None:
     print(
         json.dumps(
@@ -61,7 +54,7 @@ def main() -> int:
     if root is None:
         return 0
 
-    state = load_json(root / ".easy-coding" / "state.json") or {}
+    state = snapshot_state(root)
     task_id = state.get("current_task")
     context = [
         "[easy-coding:subagent-guard]",
@@ -69,7 +62,7 @@ def main() -> int:
         "They must not claim completion or verification without fresh evidence.",
     ]
     if task_id:
-        context.append(f"Active Easy Coding task: {task_id}")
+        context.append(f"Active Easy Coding task: {task_id} ({state['status']})")
 
     event_name = payload.get("hook_event_name") or payload.get("hookEventName") or "PreToolUse"
     emit(event_name, "\n".join(context))

package/templates/shared-hooks/inject-workflow-state.py

@@ -4,6 +4,7 @@ import os
 from pathlib import Path
 import sys
 
+from easy_coding_state import load_session
 from easy_coding_status import build_status_context
 
 
@@ -30,16 +31,6 @@ def find_ec_root(start: Path) -> Path | None:
         current = current.parent
 
 
-def load_state(root: Path) -> dict | None:
-    state_path = root / ".easy-coding" / "state.json"
-    if not state_path.exists():
-        return {"current_stage": "idle", "current_task": None}
-    try:
-        return json.loads(state_path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-
-
 def detect_agent() -> str:
     if os.environ.get("CLAUDE_PROJECT_DIR"):
         return "claude-code"
@@ -79,12 +70,12 @@ def main() -> int:
     if root is None:
         return 0
 
-    state = load_state(root)
-    if state is None:
-        return 0
+    session = load_session(root)
+    if session is None:
+        session = {"current_task": None, "created_at": ""}
 
     event_name = payload.get("hook_event_name") or payload.get("hookEventName") or "UserPromptSubmit"
-    emit(event_name, build_status_context(root, state, detect_agent()))
+    emit(event_name, build_status_context(root, session, detect_agent()))
     return 0
 
 

package/templates/shared-hooks/session-start.py

@@ -1,9 +1,11 @@
 #!/usr/bin/env python3
 import json
 import os
+from datetime import datetime, timezone
 from pathlib import Path
 import sys
 
+from easy_coding_state import load_session, write_session
 from easy_coding_status import build_status_context
 
 
@@ -59,16 +61,72 @@ def detect_agent() -> str:
     return "unknown"
 
 
-def default_state(agent: str) -> dict:
-    return {
-        "current_stage": "idle",
-        "current_task": None,
-        "last_agent": agent,
-        "stage_history": [],
-        "confirmed_by_user": False,
-        "test_strategy_confirmed": False,
-        "repo_paths": {},
-    }
+def is_process_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+def clean_stale_sessions(root: Path) -> None:
+    sessions_dir = root / ".easy-coding" / "sessions"
+    if not sessions_dir.is_dir():
+        return
+
+    now = datetime.now(timezone.utc)
+    threshold_hours = 24
+
+    for entry in sessions_dir.iterdir():
+        if not entry.suffix == ".json":
+            continue
+        try:
+            data = json.loads(entry.read_text(encoding="utf-8"))
+            created = datetime.fromisoformat(data.get("created_at", ""))
+            if created.tzinfo is None:
+                created = created.replace(tzinfo=timezone.utc)
+            age_hours = (now - created).total_seconds() / 3600
+            if age_hours <= threshold_hours:
+                continue
+            pid = int(entry.stem)
+            if is_process_alive(pid):
+                continue
+            entry.unlink()
+        except (OSError, json.JSONDecodeError, ValueError, KeyError):
+            continue
+
+
+def migrate_legacy_state(root: Path, agent: str) -> dict | None:
+    """Migrate old-format state.json into session file + task.json. Returns session dict."""
+    state_path = root / ".easy-coding" / "state.json"
+    old_state = load_json(state_path)
+    if old_state is None:
+        return None
+
+    task_id = old_state.get("current_task")
+    if task_id:
+        task_path = root / ".easy-coding" / "tasks" / str(task_id) / "task.json"
+        task = load_json(task_path)
+        if task:
+            if "stage_history" not in task or not task["stage_history"]:
+                task["stage_history"] = old_state.get("stage_history", [])
+            if "last_agent" not in task or not task["last_agent"]:
+                task["last_agent"] = old_state.get("last_agent", agent)
+            if old_state.get("confirmed_by_user"):
+                task["confirmed_by_user"] = True
+            if old_state.get("test_strategy_confirmed"):
+                task["test_strategy_confirmed"] = True
+            if old_state.get("repo_paths"):
+                task["repo_paths"] = old_state["repo_paths"]
+            write_json(task_path, task)
+
+    # Remove legacy state.json
+    try:
+        state_path.unlink()
+    except OSError:
+        pass
+
+    return {"current_task": task_id, "created_at": datetime.now(timezone.utc).isoformat()}
 
 
 def emit(event_name: str, context: str) -> None:
@@ -97,13 +155,29 @@ def main() -> int:
 
     agent = detect_agent()
     event_name = payload.get("hook_event_name") or payload.get("hookEventName") or "SessionStart"
-    state_path = root / ".easy-coding" / "state.json"
-    state = load_json(state_path)
-    if state is None:
-        state = default_state(agent)
-        write_json(state_path, state)
 
-    emit(event_name, build_status_context(root, state, agent))
+    # Migrate legacy state.json if present
+    state_path = root / ".easy-coding" / "state.json"
+    migrated_session = None
+    if state_path.exists():
+        migrated_session = migrate_legacy_state(root, agent)
+
+    # Clean stale session files
+    clean_stale_sessions(root)
+
+    # Create/overwrite session file for this session
+    session = load_session(root)
+    if session is None:
+        if migrated_session:
+            session = migrated_session
+        else:
+            session = {"current_task": None, "created_at": datetime.now(timezone.utc).isoformat()}
+    else:
+        # Refresh created_at on session start (marks session as active)
+        session["created_at"] = datetime.now(timezone.utc).isoformat()
+
+    write_session(root, session)
+    emit(event_name, build_status_context(root, session, agent))
     return 0
 
 

package/templates/common/skills/ec-init/SKILL.md

@@ -1,96 +0,0 @@
----
-name: ec-init
-description: One-time project knowledge initialization after the easy-coding CLI install. Use when the user runs {{skill_trigger}}ec-init or hook context shows [easy-coding:init-required]. Idempotent. Detects startup vs iterative projects automatically and generates SOUL, RULES, ABSTRACT, and TEST_STRATEGY.
----
-
-# ec-init — project knowledge initialization
-
-The CLI is a dumb file mover; you are the smart half. You analyze the project and produce
-the knowledge assets every later stage depends on. This runs once per project; re-runs are
-safe.
-
-Communicate with the user in the user's language.
-
-## Entry guard (idempotency — run first)
-
-1. Read `.easy-coding/tasks/project-init/task.json`.
-   - File missing → the CLI never ran. Tell the user to run `easy-coding init` first. Stop.
-   - `status == "COMPLETE"` → already initialized. Show a short summary (project mode,
-     generated files, init date from `init_log`) and exit without changing anything.
-   - `status == "PENDING"` → proceed.
-2. Repeated calls must never duplicate files or corrupt existing ones.
-
-## Project mode detection (automatic — never ask the user)
-
-Scan the project root, excluding `.easy-coding/`, platform dirs (`.claude/`, `.agents/`,
-`.codex/`, `.qoder/`), lockfiles, and pure config skeletons (package.json, tsconfig,
-linter configs, CI yaml).
-
-- Substantive source files exist (.ts/.js/.java/.py/.go/.rs/... containing real logic)
-  → **iterative** (existing project).
-- Empty, or config skeleton only → **startup** (new project).
-
-Record the verdict in `config.yaml` under `project.mode` and in `init_log`.
-
-## Iterative project flow
-
-After each step append `{step, summary, timestamp}` to `init_log` in task.json — a later
-agent must be able to see what was generated and on what evidence.
-
-1. **SOUL.md — project identity.** Analyze README, package metadata, and code purpose. Write:
-   - What this project is (2-3 sentences, concrete, no marketing fluff)
-   - Dialogue standards (language to use with the user, tone, verbosity expectations)
-   - Hard prohibitions (e.g. never commit secrets, never edit generated directories)
-   Keep it under ~40 lines; SOUL is loaded on every task.
-2. **RULES.md — coding rules grounded in evidence,** not generic best practice. Detect:
-   - Languages and versions (from configs and sources)
-   - Naming conventions actually in use (scan representative files)
-   - Comment language: if more than 70% of existing comments are Chinese, the rule is
-     "comments in Chinese"; same logic for English; mixed → follow each file's dominant language
-   - Error handling style, import ordering, formatter/linter in use (read their configs)
-   Structure as one section per language plus a General section. Every rule must be
-   mechanically checkable — "be clean" is not a rule; "exported functions carry explicit
-   return types" is.
-3. **ABSTRACT.md — architecture cognition.** Scan directory structure and entrypoints. Write:
-   modules and their responsibilities, core data flow, tech stack with versions, external
-   dependencies and services, build and run commands. Use a named section per module —
-   later stages extract sections by name (the `abstract_modules` field in execution plans).
-4. **TEST_STRATEGY.md — project test baseline:** detected framework, test command, where
-   tests live, naming conventions, coverage expectations, which classes of code this project
-   tests vs skips. Also fill `config.yaml` `test.framework` and `test.command` with commands
-   you verified exist (read package.json scripts or equivalent — do not guess).
-5. **Memory init** — ensure `.easy-coding/memory/short/` and `memory/long/` exist with the
-   three long files (MEMORY.md, BUSINESS.md, TECHNICAL.md). Never write fake entries.
-6. **Mark complete** — task.json `status:"COMPLETE"` plus a final `init_log` entry. Tell the
-   user initialization is done and daily work goes through `{{skill_trigger}}ec-workflow`.
-
-## Startup project flow
-
-1. **Lightweight interview** — 3-5 questions, strictly one at a time, multiple-choice
-   preferred: project name and positioning, primary language and framework, test framework
-   preference, special coding conventions (optional), comment language (optional).
-2. Generate from the answers:
-   - SOUL.md (identity from answers, dialogue standards, prohibitions)
-   - RULES.md (baseline rules for the chosen language; mark sections "refine as code grows")
-   - TEST_STRATEGY.md (skeleton for the chosen framework)
-3. **Skip ABSTRACT.md** — no architecture exists yet. Note in init_log:
-   "ABSTRACT pending; ec-memory backfills after the first substantive task." (ec-memory
-   detects the missing file during MEMORY_LONG and generates it from the then-current code.)
-4. Memory init and completion marking, same as iterative steps 5-6.
-5. Recommend: design first with `{{skill_trigger}}ec-brainstorming`, then build via
-   `{{skill_trigger}}ec-workflow`.
-
-## Quality bar for generated files
-
-- Every claim grounded in observed evidence — file paths and configs you actually read.
-  No filler like "follow best practices".
-- SOUL stays short. RULES and ABSTRACT run as long as the evidence supports, in named
-  sections. TEST_STRATEGY must be concrete enough that ec-verification can derive runnable
-  commands from it.
-
-## Boundaries
-
-- Never modify business source code, dependencies, or git state.
-- Never create workflow tasks or touch `current_task` / `current_stage` in state.json.
-- Never regenerate knowledge files for a COMPLETE project-init — the user edits them
-  manually or asks ec-meta for guided customization.