context-bank 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kadir Esen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# 🏦 Context Bank
+
+> **The `git init` for AI Context.**
+> Standardize, persist, and evolve your project's AI context with a single command.
+
+![License](https://img.shields.io/npm/l/context-bank)
+![Version](https://img.shields.io/npm/v/context-bank)
+
+## ⚡ The Problem
+Every time you start a new chat with an AI (Cursor, Windsurf, Copilot), you face the same issues:
+1.  **Amnesia:** You have to re-explain the tech stack and coding rules.
+2.  **Token Waste:** Pasting huge context files burns through your token limit and money.
+3.  **Inconsistency:** `Cursor` follows one rule, `Copilot` follows another.
+
+## 🚀 The Solution
+**Context Bank** creates a standardized, self-evolving brain for your project.
+
+Run one command:
+```bash
+npx context-bank init
+```
+
+And get a fully configured `.ai` environment that works across **Cursor**, **Windsurf**, and **GitHub Copilot**.
+
+## ✨ Key Features
+
+### 1. 🧠 Self-Evolving Rules (The "Living" Standard)
+Instead of static rules, Context Bank sets up a **Single Source of Truth** (`.ai/rules.md`).
+- The AI is instructed to **update this file itself** when you change a preference.
+- *Example:* You tell the AI "Don't use `any`". The AI updates `rules.md`. Next time, it remembers.
+
+### 2. 💾 Smart Memory & Token Saving
+**Stop reading the entire chat history.**
+Context Bank introduces a "State Management" system for your AI:
+- **`.ai/active-context.md` (Short-term Memory):** Keeps track of *current* tasks.
+  - *Benefit:* You can delete your chat history to save tokens, start a fresh session, and the AI knows exactly where it left off by reading this 20-line file instead of a 10k token history.
+- **`.ai/story.md` (Long-term Memory):** logs major milestones and architectural decisions.
+
+### 3. 🔌 Tool Agnostic
+Whether you switch from Cursor to Windsurf, or use Copilot in VS Code, they all share the same brain.
+- Generates `.cursorrules` pointing to the master rules.
+- Generates `.windsurfrules` pointing to the master rules.
+- Generates `.github/copilot-instructions.md` pointing to the master rules.
+
+## 🛠 Usage
+
+1.  **Go to your project root:**
+    ```bash
+    cd my-awesome-project
+    ```
+
+2.  **Initialize the bank:**
+    ```bash
+    npx context-bank init
+    ```
+
+3.  **That's it!**
+    You will see a new `.ai/` directory.
+    - **Edit `.ai/rules.md`** initially to set your stack (e.g., "React, Tailwind").
+    - **Start coding.** Your AI is now context-aware.
+
+## 📂 File Structure
+
+```text
+.
+├── .ai/
+│   ├── rules.md           # The Master Brain. SSOT for all rules.
+│   ├── active-context.md  # Current focus. "What are we doing now?"
+│   └── story.md           # Project history. "What have we done?"
+├── .cursorrules           # Pointer for Cursor AI
+├── .windsurfrules         # Pointer for Windsurf IDE
+└── .github/
+    └── copilot-instructions.md # Pointer for GitHub Copilot
+```
+
+## 🤝 Contributing
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+ISC

package/dist/commands/init.js

@@ -0,0 +1,89 @@
+import { intro, outro, confirm, spinner } from "@clack/prompts";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+// Get __dirname equivalent in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function initCommand(options) {
+    intro(chalk.bgCyan(chalk.black(" Context Bank ")));
+    let proceed = options.yes;
+    if (!proceed) {
+        const response = await confirm({
+            message: "Do you want to initialize AI context in this project?",
+        });
+        if (typeof response === "boolean") {
+            proceed = response;
+        }
+        else {
+            // Handle cancellation (ctrl+c) which returns symbol or strictly check boolean
+            proceed = false;
+        }
+    }
+    if (!proceed) {
+        outro("Operation cancelled.");
+        process.exit(0);
+    }
+    // Determine paths
+    // When running from source (ts-node), templates are in ../../templates
+    // When running from dist (node), templates are in ../../templates (copied during build)
+    // We need to ensure templates are included in the build or package.
+    const templateDir = path.resolve(__dirname, "../../templates");
+    const targetDir = process.cwd();
+    const s = spinner();
+    s.start("Analyzing project structure...");
+    // Check if templates exist
+    if (!fs.existsSync(templateDir)) {
+        s.stop("Error");
+        console.error(chalk.red(`\nTemplate directory not found at: ${templateDir}`));
+        console.error(chalk.yellow("Ensure you are running this from the package root or the package is built correctly."));
+        process.exit(1);
+    }
+    s.message("Copying context files...");
+    try {
+        // List of files/folders to copy
+        const itemsToCopy = [".ai", ".cursorrules", ".windsurfrules", ".github"];
+        for (const item of itemsToCopy) {
+            const srcPath = path.join(templateDir, item);
+            const destPath = path.join(targetDir, item);
+            if (fs.existsSync(srcPath)) {
+                // Check if destination exists
+                if (fs.existsSync(destPath)) {
+                    // For now, we skip existing files to be safe, or we could ask.
+                    // Let's just overwrite for MVP or maybe log it.
+                    // A better UX would be to ask, but let's stick to simple first.
+                    // We will use overwrite=false logic effectively by checking existence.
+                    // Actually, let's just copy and overwrite for now as this is "init",
+                    // but maybe backup?
+                    // Let's stick to standard "copy" behavior (overwrite).
+                    await fs.copy(srcPath, destPath, { overwrite: true });
+                }
+                else {
+                    await fs.copy(srcPath, destPath);
+                }
+            }
+        }
+        // Special handling for story.md date
+        const storyPath = path.join(targetDir, ".ai/story.md");
+        if (fs.existsSync(storyPath)) {
+            let storyContent = await fs.readFile(storyPath, "utf-8");
+            storyContent = storyContent.replace("[Auto-filled by init]", new Date().toISOString().split("T")[0]);
+            await fs.writeFile(storyPath, storyContent);
+        }
+        s.stop(chalk.green("Context initialized!"));
+        outro(chalk.green(`
+Context Bank setup complete! 🚀
+
+Next steps:
+1. Review .ai/rules.md and fill in your project details.
+2. Update .ai/active-context.md with your current task.
+3. Commit the new files to git.
+    `));
+    }
+    catch (error) {
+        s.stop("Error");
+        console.error(chalk.red("Failed to copy files:"), error);
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+const program = new Command();
+// Read package.json to get version
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageJson = fs.readJsonSync(path.join(__dirname, "../package.json"));
+program
+    .name("context-bank")
+    .description("CLI to standardize AI context in projects")
+    .version(packageJson.version);
+program
+    .command("init")
+    .description("Initialize AI context files in the current directory")
+    .option("-y, --yes", "Skip confirmation prompt")
+    .action(initCommand);
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "context-bank",
+  "version": "0.0.1",
+  "description": "A CLI tool to standardise AI context in projects.",
+  "type": "module",
+  "bin": {
+    "context-bank": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write ."
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "context",
+    "developer-tools"
+  ],
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}

package/templates/.ai/active-context.md

@@ -0,0 +1,23 @@
+# 🚀 Active Context & Current State
+
+> **AI AGENT INSTRUCTION:**
+> This file contains the **current focus** of the project.
+> **Update this file** at the end of every significant task or session.
+> When starting a new session, **READ THIS FIRST** to understand where we left off.
+
+## 🎯 Current Focus
+*What are we working on right now? (e.g., "Implementing the Auth system", "Refactoring the API")*
+
+- [ ] Task 1
+- [ ] Task 2
+
+## 🔄 Recent Changes
+*Briefly list what was just completed.*
+- ...
+
+## 🚧 Known Issues / Blockers
+- ...
+
+## 🔜 Next Steps
+*What should happen immediately after the current task?*
+- ...

package/templates/.ai/rules.md

@@ -0,0 +1,44 @@
+# 🧠 Project Context & Rules (Master File)
+
+> **AI AGENT INSTRUCTION (CRITICAL):**
+> This file is your **Long-Term Memory**. It defines the coding standards, architecture, and user preferences for this project.
+>
+> **YOUR CORE MISSION: SELF-EVOLUTION & MEMORY MANAGEMENT**
+> You are responsible for keeping this `.ai/` directory up-to-date.
+>
+> 1.  **Capture Preferences:** If the user specifies a preference, update **`rules.md`**.
+> 2.  **Track Progress:** At the end of a task, update **`active-context.md`** with the current status and next steps.
+> 3.  **Log History:** When a major milestone is reached, append it to **`story.md`**.
+>
+> **TOKEN SAVING STRATEGY:**
+> Do not rely on chat history for long-term memory. Rely on these files.
+> If the user starts a new chat, you should be able to resume work instantly by reading `active-context.md`.
+>
+> ---
+
+## 🏢 Project Overview
+*Replace this with a 1-sentence description of the project.*
+
+## 🛠 Tech Stack
+- **Language:** [e.g., TypeScript, Python, Go]
+- **Framework:** [e.g., React, Django, Laravel]
+- **Database:** [e.g., PostgreSQL, MongoDB]
+- **Tools:** [e.g., Docker, PNPM, Vite]
+
+## 📏 Coding Standards (Mutable)
+*AI: Update this section based on user feedback.*
+
+- **General:** Write clean, modular, and robust code.
+- **Comments:** Explain "why", not "what".
+- **Error Handling:** Fail gracefully and log errors.
+- [AI: Add new rules here...]
+
+## 🏗 Architecture Patterns
+*AI: Update this section as the architecture evolves.*
+
+- [e.g., "Use Feature-Sliced Design"]
+- [e.g., "Service Repository Pattern"]
+
+## 📝 Workflow & Git
+- **Commits:** Use Conventional Commits (feat: ..., fix: ...).
+- **Branches:** feature/name-of-feature.

package/templates/.ai/story.md

@@ -0,0 +1,20 @@
+# 📜 Project Story & Decisions Log
+
+> **AI AGENT INSTRUCTION:**
+> This file records the **history and evolution** of the project.
+> append to this file when:
+> 1. A major feature is completed.
+> 2. A significant architectural decision is made (ADR).
+> 3. The user clarifies the long-term vision.
+
+## 📅 Project Inception
+- **Date:** [Auto-filled by init]
+- **Vision:** [Initial project goal]
+
+## 🪵 Development Log
+
+### [Date] - Phase 1: Initialization
+- Project structure created.
+- Basic configuration files added.
+
+*(AI: Append new major events below...)*

package/templates/.cursorrules

@@ -0,0 +1,13 @@
+You are an expert AI software engineer.
+
+# CRITICAL CONTEXT SOURCE
+You MUST read and follow the rules defined in **`.ai/rules.md`**.
+That file contains the single source of truth for:
+1. Tech Stack
+2. Coding Standards
+3. Architecture
+4. **Your instruction to update rules when they change.**
+
+If you cannot read `.ai/rules.md` automatically, ask the user to provide it, or check the file system.
+
+When the user gives you a new constraint, **UPDATE `.ai/rules.md`**, not this file.

package/templates/.github/copilot-instructions.md

@@ -0,0 +1,9 @@
+# GitHub Copilot Instructions
+
+You are an expert developer assisting with this project.
+
+## Context & Rules
+Please refer to **`.ai/rules.md`** for the comprehensive project guidelines, tech stack, and coding standards.
+
+## Memory Update
+If the user establishes a new convention (e.g., "We only use functional components"), please suggest an update to `.ai/rules.md` to persist this rule.

package/templates/.windsurfrules

@@ -0,0 +1,8 @@
+You are Windsurf, an expert AI coding assistant.
+
+# PRIMARY DIRECTIVE
+Your configuration and behavioral rules are stored in **`.ai/rules.md`**.
+Always prioritize the instructions found in that file.
+
+# SELF-IMPROVEMENT
+If the user provides a new coding rule or preference during this session, use your file editing capabilities to update **`.ai/rules.md`** so that the preference is remembered for future sessions.