ctxinit 0.1.0

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "ctxinit",
+  "version": "0.1.0",
+  "description": "Unified context architecture for AI coding assistants (Claude Code, Cursor, Codex)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "ctx": "./bin/ctx.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "keywords": [
+    "ai",
+    "context",
+    "claude",
+    "cursor",
+    "codex",
+    "cli",
+    "developer-tools"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "templates"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stone16/ctxinit.git"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/inquirer": "^9.0.9",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.1",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
+    "jest": "^30.2.0",
+    "prettier": "^3.7.4",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.1"
+  },
+  "dependencies": {
+    "@types/minimatch": "^5.1.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "fast-glob": "^3.3.3",
+    "gray-matter": "^4.0.3",
+    "inquirer": "^12.11.1",
+    "minimatch": "^10.1.1",
+    "yaml": "^2.8.2",
+    "zod": "^4.1.13"
+  }
+}

package/templates/architecture.md

@@ -0,0 +1,35 @@
+# Architecture Overview
+
+<!-- This file describes your project's architecture for AI assistants -->
+
+## System Design
+
+<!-- Describe the high-level architecture -->
+
+## Component Structure
+
+<!-- Explain how components are organized -->
+
+## Data Flow
+
+<!-- Describe how data moves through the system -->
+
+## Key Patterns
+
+<!-- Document important design patterns used -->
+
+### Pattern 1: [Name]
+
+<!-- Description and usage -->
+
+## Dependencies
+
+<!-- List external dependencies and their purposes -->
+
+## Security Considerations
+
+<!-- Note any security-related architectural decisions -->
+
+## Performance Considerations
+
+<!-- Document performance-related architectural choices -->

package/templates/bootstrap-prompt.md

@@ -0,0 +1,242 @@
+# Context Bootstrap Request
+
+You are helping bootstrap AI coding rules for the project "{{projectName}}".
+
+Your goal is to generate modular rule files for the `.context/rules/` directory that will compile into a production-grade CLAUDE.md (or equivalent agent instruction file).
+
+---
+
+## Critical Philosophy: Context Engineering Principles
+
+Before generating rules, internalize these principles:
+
+### 1. CLAUDE.md is NOT Documentation for Humans
+
+It is a **system prompt injection mechanism** - the operating system for an AI agent. Every line must:
+- Be **machine-actionable**, not human-readable prose
+- Be **concise**, **imperative**, and **unambiguous**
+- Purchase significant agentic behavior (treat context as high-value real estate)
+
+### 2. Respect LLM Cognitive Architecture
+
+LLMs are stateless with limited attention. Key constraints:
+- **Lost in the middle**: Transformers degrade attention mid-context
+- **Saturation point**: ~150-200 distinct instructions is the practical limit
+- **Relevance filtering**: Claude Code ignores context that appears irrelevant to current task
+
+**Therefore**: Less is more. Dense, actionable instructions beat verbose explanations.
+
+### 3. Never Use CLAUDE.md as a Linter
+
+LLMs are probabilistic engines. For deterministic rules (formatting, naming conventions), use actual linters. Reserve CLAUDE.md for:
+- Architectural decisions
+- Workflow patterns
+- Domain-specific context
+- Things that can't be automated
+
+### 4. Progressive Disclosure Pattern
+
+Don't load everything into root CLAUDE.md. Instead:
+- Root file acts as **map and index**
+- Detailed docs live in `agent_docs/` or `.context/` subdirectories
+- Use referral instructions: "When modifying X, first read `@path/to/detail.md`"
+
+---
+
+## Project Analysis
+
+**Project Name**: {{projectName}}
+**Primary Languages**: {{languages}}
+**Frameworks**: {{frameworks}}
+**Build Tools**: {{buildTools}}
+**Testing**: {{testingTools}}
+
+## Directory Structure
+
+**Top-level directories**: {{topLevelDirs}}
+**Source structure**: {{srcStructure}}
+**Has tests**: {{hasTests}}
+**Has docs**: {{hasDocs}}
+
+{{#packageInfo}}
+## Package Information
+
+**Type**: {{type}}
+**Description**: {{description}}
+**Key Dependencies**: {{dependencies}}
+**Scripts**: {{scripts}}
+{{/packageInfo}}
+
+{{#existingDocs}}
+## Existing Documentation
+
+The following documentation already exists:
+
+{{#docs}}
+### {{path}}
+```text
+{{excerpt}}
+```
+{{/docs}}
+{{/existingDocs}}
+
+{{#sampleFiles}}
+## Sample Code Files
+
+These files represent the coding patterns in this project:
+
+{{#files}}
+### {{path}} ({{language}})
+```{{languageLower}}
+{{content}}
+```
+{{/files}}
+{{/sampleFiles}}
+
+---
+
+## Your Task: Generate Production-Grade Rules
+
+Create **3-7 rule files** following the architecture below. Each rule should be **dense and actionable**.
+
+### Required Rule Categories
+
+#### 1. Project Identity Rule (`project-identity.md`)
+Must include:
+- One-line mission statement
+- Tech stack summary (language, framework, database, infra)
+- Architectural style (monorepo/microservices/modular monolith)
+
+#### 2. Architecture Map Rule (`architecture-map.md`)
+Must include:
+- ASCII tree or descriptive map of key directories
+- Purpose of each major directory
+- This prevents agents from wasting tokens running `ls`, `find`, `grep` to understand structure
+
+#### 3. Operational Commands Rule (`commands.md`)
+Must include authoritative commands for:
+- Build
+- Test (unit, integration, e2e)
+- Lint/Format
+- Database migrations (if applicable)
+- Deployment (if applicable)
+
+Format as imperative instructions:
+```text
+# Build
+Run: `npm run build`
+
+# Test
+Run: `npm test` for unit tests
+Run: `npm run test:e2e` for e2e tests
+```
+
+#### 4. Code Patterns Rule (language-specific, e.g., `typescript-patterns.md`)
+Based on the sample files, document:
+- Import organization
+- Error handling patterns
+- Async patterns
+- Naming conventions (only if non-standard)
+
+**Important**: Don't duplicate what linters enforce. Focus on patterns that require judgment.
+
+#### 5. Do-Not Rules (`boundaries.md`)
+Critical prohibitions. Format as imperative negatives:
+```text
+- Do NOT modify files in `dist/` or `build/` directly
+- Do NOT commit `.env` files
+- Do NOT add dependencies without approval
+- Do NOT use `any` type in TypeScript
+```
+
+#### 6. Git Workflow Rule (`git-workflow.md`)
+Must include:
+- Always submit changes via Pull Request, never commit directly to main
+- Do NOT include "Co-authored-by" in commit messages
+- Commit message format and conventions
+- Branch naming conventions
+
+### Optional Rules (if applicable)
+
+#### 7. Testing Conventions (`testing.md`)
+If testing tools detected, document:
+- Test file location pattern
+- Mocking conventions
+- Test naming conventions
+- Coverage requirements
+
+#### 8. Framework-Specific Patterns
+If frameworks detected, create framework-specific rules.
+
+---
+
+## Rule File Format
+
+Each rule must follow this exact format:
+
+```markdown
+---
+id: unique-rule-id
+description: Brief description (machine-readable)
+globs:
+  - "**/*.ts"
+priority: 50
+tags:
+  - category
+---
+
+# Rule Title
+
+[Dense, imperative instructions here]
+
+## Section Name
+
+- Bullet points preferred over paragraphs
+- Each point is a discrete instruction
+- Use code blocks for commands and examples
+
+## Examples (if needed)
+
+\`\`\`typescript
+// GOOD: Brief explanation
+code example
+\`\`\`
+
+\`\`\`typescript
+// AVOID: Brief explanation
+anti-pattern
+\`\`\`
+```
+
+### Writing Style Guidelines
+
+1. **Imperative voice**: "Use X" not "You should use X" or "X is recommended"
+2. **Dense**: One instruction per line, no filler words
+3. **Specific**: Include file paths, line number references where helpful
+4. **Actionable**: Every sentence should change agent behavior
+5. **No prose**: Avoid explanatory paragraphs. Use structured lists.
+
+### Anti-Patterns to Avoid
+
+- Generic advice ("write clean code", "follow best practices")
+- Duplicating linter rules
+- Long explanations of "why"
+- Vague instructions ("be careful with X")
+- Marketing language ("elegant", "robust", "scalable")
+
+---
+
+## Output Format
+
+For each rule, output:
+
+1. **Filename**: `rule-name.md` (kebab-case)
+2. **Full content**: Complete rule file with frontmatter
+
+Create files for `.context/rules/`. Be specific to THIS project's patterns, not generic advice.
+
+---
+
+## Generate Rules Now
+
+Analyze the codebase information above. Generate dense, actionable rule files that will make an AI agent effective at working in this specific codebase.

package/templates/config.yaml

@@ -0,0 +1,25 @@
+# ctxinit Configuration
+# Documentation: https://github.com/your-org/ctxinit
+
+version: "1.0"
+
+compile:
+  # Claude Code target configuration
+  claude:
+    max_tokens: 4000
+    strategy: priority  # priority | directory | glob | tag | all
+    always_include: []
+
+  # Cursor target configuration
+  cursor:
+    strategy: all
+
+  # AGENTS.md target configuration
+  agents:
+    max_tokens: 8000
+    strategy: priority
+    include_dirs: []
+
+# Conflict resolution when rules overlap
+conflict_resolution:
+  strategy: priority_wins  # priority_wins | merge

package/templates/project.md

@@ -0,0 +1,44 @@
+# Project Context
+
+<!-- This file provides global context about your project for AI assistants -->
+
+## Overview
+
+<!-- Describe your project in 2-3 sentences -->
+
+## Tech Stack
+
+<!-- List primary technologies, frameworks, and tools -->
+
+- Language:
+- Framework:
+- Database:
+- Build Tool:
+
+## Key Directories
+
+<!-- Explain important directories in your project -->
+
+```
+src/           # Source code
+tests/         # Test files
+docs/          # Documentation
+```
+
+## Coding Standards
+
+<!-- Summarize key coding conventions -->
+
+- Follow existing patterns in the codebase
+- Write tests for new features
+- Keep functions focused and small
+
+## Common Commands
+
+<!-- List frequently used commands -->
+
+```bash
+npm run dev     # Start development server
+npm run test    # Run tests
+npm run build   # Build for production
+```

package/templates/rules/example.md

@@ -0,0 +1,36 @@
+---
+id: example-rule
+description: An example rule demonstrating the frontmatter format
+domain: general
+globs:
+  - "**/*.ts"
+  - "**/*.js"
+priority: 50
+tags:
+  - example
+  - template
+---
+
+# Example Rule
+
+This is an example rule file. Replace this content with your actual coding guidelines.
+
+## Guidelines
+
+1. **Code Style**: Follow consistent formatting
+2. **Naming**: Use descriptive variable and function names
+3. **Documentation**: Add comments for complex logic
+
+## Examples
+
+```typescript
+// Good: Descriptive function name
+function calculateTotalPrice(items: Item[]): number {
+  return items.reduce((sum, item) => sum + item.price, 0);
+}
+
+// Avoid: Unclear naming
+function calc(i: any[]): number {
+  return i.reduce((s, x) => s + x.p, 0);
+}
+```