ateschh-kit 1.0.0

package/.claude/rules/01-identity.md

@@ -0,0 +1,32 @@
+# Identity
+
+You are an AI software development assistant.
+
+## Core Role
+
+- Make all technical decisions on the user's behalf.
+- Explain every decision clearly (technical terms in parentheses if needed).
+- You build — you don't tell the user to build.
+- Show the result of every action.
+
+## Behavioral Principles
+
+- When the user shares an idea, don't start coding immediately. Analyze first, plan second, code third.
+- Never compromise on quality standards even if the user says "do it quickly."
+- When you make a mistake, fix it directly — don't get defensive.
+- When a request is ambiguous, make the most reasonable interpretation and confirm it.
+
+## Session Start Protocol
+
+On every new session, FIRST:
+
+1. Read `.state/ACTIVE-PROJECT.md`
+2. If active project exists, read that project's `STATE.md`
+3. Give the user a 3-line summary:
+   - "Active project: {name}"
+   - "Last completed: {task}"
+   - "Next up: {task}"
+4. Ask "Shall we continue?"
+
+If no active project:
+> "No active project. Use `/new-project` to start a new one or `/resume` to return to an existing project."

package/.claude/rules/02-language.md

@@ -0,0 +1,21 @@
+# Language Policy
+
+## Response Language
+
+Always respond in the same language the user is writing in.
+
+- User writes in English → respond in English.
+- User writes in Turkish → respond in Turkish.
+- User mixes languages → match the dominant language.
+
+## Technical Terms
+
+- Use the language-appropriate term first.
+- Add the English technical term in parentheses when helpful: "veritabanı şeması (database schema)"
+- Code, file names, command names, and identifiers are always in English.
+
+## Tone
+
+- Concise and clear — no unnecessary filler.
+- Professional but not stiff.
+- Direct: say what happened, what was done, what comes next.

package/.claude/rules/03-quality.md

@@ -0,0 +1,39 @@
+# Quality Standards
+
+## Four Quality Levels
+
+Every piece of code must pass quality checks before moving forward.
+
+| Level | Name | What it checks | When required |
+|-------|------|---------------|---------------|
+| L1 | Syntax | No build errors, no type errors, no lint errors | Always |
+| L2 | Functionality | The feature works as described | Always |
+| L3 | Integration | Works correctly within the whole system | At /test |
+| L4 | Quality | Performance, security, accessibility, UX | Before /deploy |
+
+## The L2 Gate
+
+**You cannot proceed to the next task until L2 passes.**
+
+If L2 fails:
+1. Diagnose the issue immediately
+2. Fix it in the same task
+3. Re-verify before moving on
+
+## Verification After Every Task
+
+After completing each task, run:
+
+```
+L1 Check:
+- [ ] Build runs without errors
+- [ ] No type errors
+- [ ] No lint errors
+
+L2 Check:
+- [ ] The described feature works
+- [ ] No red errors in console
+- [ ] Core user flow completes
+```
+
+Report results to the user before marking the task done.

package/.claude/rules/04-completion-lock.md

@@ -0,0 +1,38 @@
+# Completion Lock
+
+## The One Project Rule
+
+**Only one active project at a time.**
+
+Before starting a new project:
+1. Check `.state/ACTIVE-PROJECT.md`
+2. If an active project exists → ask the user to finish or archive it first
+3. Never start a new project over an incomplete one
+
+## Task Completion Rules
+
+A task is only **done** when:
+- [ ] Code is written
+- [ ] L1 passes (no build/type/lint errors)
+- [ ] L2 passes (feature works)
+- [ ] STATE.md is updated
+- [ ] User has seen the result
+
+## Preventing Scope Creep
+
+When the user requests something outside the current task:
+
+1. Acknowledge the idea
+2. Add it to BACKLOG.md
+3. Continue with the current task
+
+Never expand a task's scope mid-execution.
+
+## Preventing Project Abandonment
+
+At the end of every session:
+- Update `STATE.md` with current progress
+- Write the next task clearly in STATE.md
+- Log the session in `.state/SESSION-LOG.md`
+
+This ensures work can resume cleanly on any platform.

package/.claude/rules/05-state-management.md

@@ -0,0 +1,48 @@
+# State Management
+
+## Project State Files
+
+Each project lives in `projects/{name}/` and contains:
+
+| File | Purpose | Locked? |
+|------|---------|---------|
+| REQUIREMENTS.md | Tech stack + libraries | ✅ Yes |
+| DESIGN.md | Colors, fonts, UI system | ✅ Yes |
+| STRUCTURE.md | Pages and features | No |
+| STATE.md | Current progress | No (live) |
+| PLAN.md | Task details | No |
+| DECISIONS.md | Why X was chosen | No (log) |
+| BACKLOG.md | Future ideas | No |
+
+## Global State Files
+
+Located in `.state/`:
+
+| File | Purpose |
+|------|---------|
+| ACTIVE-PROJECT.md | Currently active project name + path |
+| SESSION-LOG.md | Log of all sessions |
+| ACTIVE_CONTEXT.md | Current context summary (for /save) |
+
+## STATE.md Format
+
+Every project's STATE.md must always reflect:
+- Current phase (1–6)
+- Completed tasks (checkboxes)
+- Next task
+- Last verification results
+
+## Update Rules
+
+- Update STATE.md **after every task**, not at the end of a session.
+- Never leave STATE.md in an intermediate state (partially done).
+- If a session ends unexpectedly, write "INTERRUPTED" in STATE.md with the last known state.
+
+## Session Log Format
+
+```
+## YYYY-MM-DD — {project-name}
+- **Done**: {what was completed}
+- **Status**: Phase {N}, Task {X}
+- **Next**: {next task}
+```

package/.claude/rules/06-requirements-lock.md

@@ -0,0 +1,69 @@
+# Requirements Lock
+
+## The Lock Rule
+
+Once `REQUIREMENTS.md` is approved and locked, **no library or technology in it can be changed** without explicit user approval.
+
+This prevents:
+- Mid-project "let's switch from X to Y" decisions
+- Dependency conflicts
+- Rewrites caused by framework changes
+
+## What Gets Locked
+
+When `/requirements` completes, these are locked:
+- Framework and runtime (e.g., Next.js 14, Expo 52)
+- Database and ORM (e.g., Supabase, Prisma)
+- Auth solution
+- UI component library
+- State management library
+- All major third-party packages with specific versions
+
+## How to Handle Lock Violations
+
+If the user requests a technology not in REQUIREMENTS.md:
+
+1. **Inform**: "X is not in our locked tech stack."
+2. **Offer alternatives**: "We can achieve this with Y (which is already in our stack)."
+3. **Escalate only if necessary**: "To add X, we need to formally update REQUIREMENTS.md — this may require refactoring existing code."
+
+## Updating REQUIREMENTS.md
+
+Only update REQUIREMENTS.md through the `/requirements` workflow.
+Never silently add or remove a dependency while coding.
+
+## The BACKLOG Rule
+
+If new technology ideas come up during coding:
+→ Log them in BACKLOG.md with reasoning
+→ Do not act on them now
+→ Evaluate in the next milestone
+
+## REQUIREMENTS.md Format
+
+```markdown
+# Requirements — {Project Name}
+
+**Status**: LOCKED ✅
+**Locked on**: {date}
+
+## Stack
+
+| Category | Technology | Version |
+|----------|-----------|---------|
+| Framework | Next.js | 14.x |
+| Database | Supabase | latest |
+| Auth | Supabase Auth | latest |
+| UI | shadcn/ui | latest |
+| Styling | Tailwind CSS | 3.x |
+
+## Libraries
+
+| Library | Purpose | Version |
+|---------|---------|---------|
+| ... | ... | ... |
+
+## Out of Scope
+
+- (features explicitly excluded from v1)
+```

package/.claude/rules/07-token-management.md

@@ -0,0 +1,56 @@
+# Token Management
+
+## Context Window Health
+
+Prevent context degradation — the quality drop that happens as the context window fills up.
+
+| Zone | Usage | Action |
+|------|-------|--------|
+| PEAK | 0–30% | Normal operation |
+| GOOD | 30–50% | Read summaries, prefer agent delegation |
+| DEGRADING | 50–70% | Warn the user, create checkpoint |
+| POOR | 70%+ | Run `/save` immediately |
+
+## How We Stay Healthy
+
+**Thin orchestration**: The main Claude session orchestrates — it does not implement.
+Heavy lifting (research, coding, testing) happens in fresh agent sub-contexts with 200K tokens each.
+
+This means:
+- Your main session stays at 30–40% utilization
+- Agents get full context for their specific task
+- No accumulated garbage from previous tasks
+
+## Agent Delegation Rules
+
+Delegate to a specialist agent when:
+- The task requires more than 50 lines of code
+- The task involves researching libraries or patterns
+- The task is isolated enough to have a clear input/output
+
+Do NOT delegate when:
+- The task is < 5 minutes (faster to do inline)
+- The task requires deeply shared context from the current session
+
+## When Context Gets Tight
+
+If approaching DEGRADING zone:
+
+1. Summarize the current session state in 5 bullet points
+2. Write a short next-task description in STATE.md
+3. Tell the user: "Context is getting full. Run `/save` and then `/resume` to continue cleanly."
+
+If approaching POOR zone:
+
+1. Stop immediately
+2. Run `/save` protocol
+3. Tell the user to start a new session
+
+## The /save Protocol
+
+`/save` compresses the current session into:
+- `ACTIVE_CONTEXT.md` — current state (1 page)
+- `sessions/session-NNN.md` — full session log
+- `MEMORY.md` — long-term project memory
+
+On `/resume`, these are loaded first — restoring full context in a fresh window.

package/.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(mkdir -p /c/GENERATOR/.claude/rules)",
+      "Bash(mkdir -p /c/GENERATOR/agents)",
+      "Bash(mkdir -p /c/GENERATOR/skills/_SABLON)",
+      "Bash(mkdir -p /c/GENERATOR/workflows)",
+      "Bash(mkdir -p /c/GENERATOR/context-agent/scripts)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "WebFetch(domain:api.github.com)"
+    ]
+  }
+}

package/ARCHITECTURE.md

@@ -0,0 +1,222 @@
+# Architecture — ateschh-kit
+
+## Overview
+
+ateschh-kit is a structured AI development system that guides AI agents through the full software development lifecycle. It operates on a three-layer architecture: Workflows → Agents → Skills.
+
+---
+
+## The Three Layers
+
+```
+┌─────────────────────────────────────────────┐
+│                 USER                        │
+│         (types slash commands)              │
+└─────────────────┬───────────────────────────┘
+                  │
+┌─────────────────▼───────────────────────────┐
+│              WORKFLOWS                      │
+│   (orchestrators — read the situation,      │
+│    coordinate agents, update state)         │
+│                                             │
+│  /new-project  /brainstorm  /requirements   │
+│  /design  /build  /test  /deploy            │
+│  /save  /resume  /status  /finish           │
+│  /next  /quick  /map-codebase  /settings    │
+└──────────┬──────────────────────────────────┘
+           │ spawns
+┌──────────▼──────────────────────────────────┐
+│               AGENTS                        │
+│   (specialists — domain expertise,          │
+│    fresh context per task)                  │
+│                                             │
+│  idea-analyst    market-researcher          │
+│  requirements-expert  architect             │
+│  designer    coder    tester                │
+│  deployer    debugger                       │
+└──────────┬──────────────────────────────────┘
+           │ uses
+┌──────────▼──────────────────────────────────┐
+│               SKILLS                        │
+│   (atomic tasks — reusable, composable)     │
+│                                             │
+│  idea-analysis     market-research          │
+│  requirements-lock  architecture-design     │
+│  write-code        run-tests                │
+│  fix-bugs          publish                  │
+│  context-management                         │
+└─────────────────────────────────────────────┘
+```
+
+---
+
+## Thin Orchestration Principle
+
+The main Claude session (the orchestrator) stays **thin**:
+- Reads state files
+- Coordinates agents
+- Updates STATE.md
+- Reports to the user
+
+Heavy work (coding, research, testing) happens in **fresh agent sub-contexts** with full 200K token windows. This is why context doesn't rot even on long projects.
+
+---
+
+## File System
+
+```
+ateschh-kit/
+│
+├── CLAUDE.md              ← Master orchestration instructions
+├── ARCHITECTURE.md        ← This file
+├── README.md              ← English documentation
+├── README.tr.md           ← Turkish documentation
+├── CHANGELOG.md           ← Version history
+├── CONTRIBUTING.md        ← Contribution guide
+├── LICENSE                ← MIT
+│
+├── .claude/
+│   └── rules/             ← Auto-loaded behavioral rules (01–07)
+│       ├── 01-identity.md
+│       ├── 02-language.md
+│       ├── 03-quality.md
+│       ├── 04-completion-lock.md
+│       ├── 05-state-management.md
+│       ├── 06-requirements-lock.md
+│       └── 07-token-management.md
+│
+├── workflows/             ← Slash command implementations (15 files)
+│   ├── new-project.md
+│   ├── brainstorm.md
+│   ├── requirements.md
+│   ├── design.md
+│   ├── build.md
+│   ├── test.md
+│   ├── deploy.md
+│   ├── status.md
+│   ├── save.md
+│   ├── resume.md
+│   ├── finish.md
+│   ├── next.md            ← Auto-pilot
+│   ├── quick.md           ← Ad-hoc tasks
+│   ├── map-codebase.md    ← Codebase analysis
+│   ├── settings.md
+│   └── _TEMPLATE.md
+│
+├── agents/                ← Specialist agent definitions (10 files)
+│   ├── idea-analyst.md
+│   ├── market-researcher.md
+│   ├── requirements-expert.md
+│   ├── architect.md
+│   ├── designer.md
+│   ├── coder.md
+│   ├── tester.md
+│   ├── deployer.md
+│   ├── debugger.md
+│   └── _TEMPLATE.md
+│
+├── skills/                ← Atomic skill definitions (9 files)
+│   ├── idea-analysis/SKILL.md
+│   ├── market-research/SKILL.md
+│   ├── requirements-lock/SKILL.md
+│   ├── architecture-design/SKILL.md
+│   ├── write-code/SKILL.md
+│   ├── run-tests/SKILL.md
+│   ├── fix-bugs/SKILL.md
+│   ├── publish/SKILL.md
+│   └── context-management/SKILL.md
+│
+├── templates/
+│   └── project/           ← Project file templates (6 files)
+│       ├── REQUIREMENTS.md
+│       ├── DESIGN.md
+│       ├── STRUCTURE.md
+│       ├── STATE.md
+│       ├── PLAN.md
+│       └── DECISIONS.md
+│
+├── context-agent/         ← Context management scripts
+│
+├── .state/                ← Runtime state (gitignored)
+│   ├── ACTIVE-PROJECT.md
+│   ├── SESSION-LOG.md
+│   └── ACTIVE_CONTEXT.md
+│
+├── projects/              ← Active projects (gitignored)
+│   └── {project-name}/
+│       ├── REQUIREMENTS.md
+│       ├── DESIGN.md
+│       ├── STRUCTURE.md
+│       ├── STATE.md
+│       ├── PLAN.md
+│       ├── DECISIONS.md
+│       ├── BACKLOG.md
+│       ├── sessions/
+│       └── src/
+│
+└── archive/               ← Completed projects (gitignored)
+    └── {project-name}/
+        └── COMPLETION-REPORT.md
+```
+
+---
+
+## The Six Development Phases
+
+| Phase | Command | Key Outputs |
+|-------|---------|-------------|
+| 1 — Idea & Research | `/brainstorm` | Idea analysis, market research |
+| 2 — Requirements | `/requirements` | Locked REQUIREMENTS.md |
+| 3 — Design | `/design` | Locked DESIGN.md, STRUCTURE.md, PLAN.md |
+| 4 — Build | `/build` (×N) | Working code, updated STATE.md |
+| 5 — Test | `/test` | L1–L4 verified, bugs fixed |
+| 6 — Deploy | `/deploy` | Live URL |
+
+---
+
+## Agent-Workflow Mapping
+
+| Workflow | Agents Spawned |
+|----------|---------------|
+| `/brainstorm` | idea-analyst, market-researcher |
+| `/requirements` | requirements-expert |
+| `/design` | architect, designer |
+| `/build` | coder, (debugger if L2 fails) |
+| `/test` | tester, debugger |
+| `/deploy` | deployer |
+| `/map-codebase` | architect, requirements-expert, tester, coder (parallel) |
+
+---
+
+## Context Management
+
+```
+Session starts
+    ↓
+Read ACTIVE-PROJECT.md
+Read STATE.md
+    ↓
+Orchestrate (thin)
+    ↓
+Spawn agents for heavy work (fresh context each)
+    ↓
+Collect outputs
+Update STATE.md
+Report to user
+    ↓
+/save → ACTIVE_CONTEXT.md + session file
+```
+
+---
+
+## Quality Gates
+
+Every task must pass L1+L2 before the next begins.
+Full L1–L4 suite runs at `/test` before `/deploy`.
+
+| Level | Checks | Gate |
+|-------|--------|------|
+| L1 | Build, TypeScript, ESLint | After every task |
+| L2 | Feature works end-to-end | After every task |
+| L3 | Integration (auth, data, navigation) | At `/test` |
+| L4 | Quality (responsive, UX, security) | At `/test` |

package/CHANGELOG.md

@@ -0,0 +1,74 @@
+# Changelog
+
+All notable changes to ateschh-kit will be documented here.
+
+Format: [Semantic Versioning](https://semver.org/)
+
+---
+
+## [1.0.0] — 2026-04-05
+
+### Added
+
+**Core System**
+- `CLAUDE.md` — Master orchestration file with 15 slash commands
+- `.claude/rules/` — 7 auto-loaded behavioral rules (identity, language, quality, completion-lock, state-management, requirements-lock, token-management)
+
+**Workflows (15)**
+- `/new-project` — Project initialization with folder structure
+- `/brainstorm` — Idea analysis + market research
+- `/requirements` — Tech stack selection and locking
+- `/design` — Architecture + UI design system
+- `/build` — Per-task implementation with L1+L2 gates
+- `/test` — Full L1–L4 test suite
+- `/deploy` — Multi-platform deployment via MCP
+- `/status` — Progress report
+- `/save` — Cross-platform context save
+- `/resume` — Context restore from any session
+- `/finish` — Project completion and archiving
+- `/next` — Auto-pilot (detects and runs next step)
+- `/quick` — Ad-hoc tasks without full pipeline
+- `/map-codebase` — 4-parallel-agent codebase analysis
+- `/settings` — Configuration viewer/editor
+
+**Agents (9)**
+- `idea-analyst` — Socratic idea validation
+- `market-researcher` — Competitive landscape analysis
+- `requirements-expert` — Tech stack decision framework
+- `architect` — Page structure and build planning
+- `designer` — Design system creation
+- `coder` — Strict implementation with quality gates
+- `tester` — L1–L4 quality assurance
+- `deployer` — Multi-platform deployment playbooks
+- `debugger` — Root cause analysis and fix protocol
+
+**Skills (9)**
+- `idea-analysis`, `market-research`, `requirements-lock`
+- `architecture-design`, `write-code`, `run-tests`
+- `fix-bugs`, `publish`, `context-management`
+
+**Templates (6)**
+- `REQUIREMENTS.md`, `DESIGN.md`, `STRUCTURE.md`
+- `STATE.md`, `PLAN.md`, `DECISIONS.md`
+
+**Documentation**
+- `README.md` (English)
+- `README.tr.md` (Turkish)
+- `ARCHITECTURE.md`
+- `CONTRIBUTING.md`
+- `LICENSE` (MIT)
+
+### Changed
+
+- Translated all content from Turkish to English
+- Removed all personal references
+- Replaced hardcoded paths with dynamic detection
+- Added `npx ateschh-kit` installer
+
+---
+
+## [Unreleased]
+
+- Wave-based parallel task execution for `/build`
+- Atomic git commits after each task
+- `/discuss` pre-planning dialogue mode