cntx-ui 2.0.13 → 3.0.0

package/templates/TOOLS.md

@@ -0,0 +1,41 @@
+# cntx-ui Tool Reference
+
+This document maps the **Model Context Protocol (MCP)** tools to their **HTTP API** equivalents.
+
+## Core Agent Tools
+
+| MCP Tool | HTTP Endpoint | Parameters | Description |
+| :--- | :--- | :--- | :--- |
+| `agent/discover` | `GET /api/status` | `scope?: string` | Architectural overview and health check. |
+| `agent/query` | `POST /api/semantic-search` | `question: string` | Semantic search across the entire codebase. |
+| `agent/investigate` | `POST /api/vector-db/search` | `feature: string` | Suggest integration points for new features. |
+| `agent/organize` | `GET /api/bundles` | `activity: string` | Audit and optimize project bundle health. |
+
+## Bundle Management
+
+| MCP Tool | HTTP Endpoint | Parameters | Description |
+| :--- | :--- | :--- | :--- |
+| `list_bundles` | `GET /api/bundles` | *None* | List all manual and smart bundles. |
+| `get_bundle` | `GET /api/bundles/:name` | `name: string` | Get full XML content of a specific bundle. |
+
+## Semantic Analysis
+
+| MCP Tool | HTTP Endpoint | Parameters | Description |
+| :--- | :--- | :--- | :--- |
+| `get_semantic_chunks`| `GET /api/semantic-chunks` | `refresh?: bool` | Get all surgically extracted code chunks. |
+| `search_by_type` | `POST /api/vector-db/search-by-type` | `type: string` | Find chunks by AST type (e.g. arrow_function). |
+| `search_by_domain` | `POST /api/vector-db/search-by-domain`| `domain: string` | Find chunks by business domain (e.g. auth). |
+
+## File Operations
+
+| MCP Tool | HTTP Endpoint | Parameters | Description |
+| :--- | :--- | :--- | :--- |
+| `read_file` | `GET /api/files/:path` | `path: string` | Read file with injected semantic metadata. |
+| `write_file` | `POST /api/files` | `path, content` | Write file with automatic backup. |
+
+## Activities
+
+| MCP Tool | HTTP Endpoint | Parameters | Description |
+| :--- | :--- | :--- | :--- |
+| `list_activities` | `GET /api/activities` | *None* | List all ongoing agent missions. |
+| `get_reasoning` | `GET /api/activities/:id/reasoning` | `id: string` | Recall agent interaction history for a task. |

package/templates/activities/README.md

@@ -0,0 +1,67 @@
+# cntx-ui Activities System
+
+This directory contains the activities management system for cntx-ui. Activities are used to plan, track, and document significant development efforts.
+
+## Guiding Principles for AI Agents
+
+**ATTENTION AI AGENT:** This is a mandatory set of rules for interacting with the cntx-ui Activities System.
+
+1.  **This is a Sequential, Multi-Step Workflow.** You **MUST** follow the 3-step process for creating activities. Do not attempt to combine steps or skip ahead. Each step uses a specific tool (`.mdc` file) and requires user confirmation before proceeding to the next.
+2.  **Context is Critical.** Before creating a new activity, you **MUST** first examine the contents of an existing activity in the `activities/` directory (e.g., `api-audit`). This will give you the required context on the structure and content of the four standard files (`README.md`, `tasks.md`, `progress.md`, `notes.md`).
+3.  **One Step at a Time.** After completing a step, you **MUST** stop and inform the user of the result. Do not automatically proceed to the next step without explicit user instruction (e.g., the user saying "go" or "proceed").
+
+## The 3-Step Activity Creation Workflow
+
+To create a new activity, you must follow these three steps in order.
+
+---
+
+### **Step 1: Create the Activity Definition**
+
+- **Goal:** To create the high-level plan (`README.md`) for the activity.
+- **Input:** A user prompt describing the feature.
+- **Tool:** `@.cntx/activities/lib/create-activity.mdc`
+- **Output:** A new directory in `.cntx/activities/activities/` containing a single `README.md` file.
+
+**Note to Agent:** After completing this step, your job is done for now. Inform the user that the Activity Definition has been created and that the next step is to generate the task list. **Wait for their command to proceed.**
+
+---
+
+### **Step 2: Generate the Task List & Register Activity**
+
+- **Goal:** To break down the high-level plan into a detailed task list and register the activity.
+- **Input:** The `README.md` file created in Step 1.
+- **Tool:** `@.cntx/activities/lib/generate-tasks.mdc`
+- **Output:**
+    1. A `tasks.md` file inside the activity's directory.
+    2. A new entry for the activity added to the `.cntx/activities/activities.json` file, including the generated tasks.
+
+**Note to Agent:** This step requires a pause for user confirmation after generating the parent tasks, as per the instructions in `generate-tasks.mdc`. After this step is fully complete, stop and wait for the user's command.
+
+---
+
+### **Step 3: Create Progress and Notes Files**
+
+- **Goal:** To create the initial tracking and notes files for the activity.
+- **Input:** The `tasks.md` file from Step 2.
+- **Tool:** `@.cntx/activities/lib/process-task-list.mdc` (and knowledge from existing examples).
+- **Output:** `progress.md` and `notes.md` files inside the activity's directory, populated with initial template content.
+
+**Note to Agent:** Once this step is complete, the entire activity has been successfully scaffolded. Inform the user and await further instructions.
+
+---
+## How to Work on Existing Activities
+
+To begin working on an existing activity, provide the agent with the activity files and use the process-task-list workflow:
+
+```text
+I want to work on the [activity-name] activity. Here are the relevant files:
+@.cntx/activities/activities/[activity-name]/README.md
+@.cntx/activities/activities/[activity-name]/tasks.md
+@.cntx/activities/activities/[activity-name]/progress.md
+
+Please start on the next uncompleted task and use @process-task-list.mdc
+```
+
+---
+This system is for internal cntx-ui project management and is not intended for public open source use.

package/templates/activities/activities/create-project-bundles/README.md

@@ -0,0 +1,84 @@
+# Create Project Bundles with Agent Assistance
+
+## Introduction/Overview
+
+Set up organized bundles for a new codebase using agent assistance to analyze project structure and suggest appropriate file groupings. This activity demonstrates how to collaborate with an AI agent to understand your project's architecture and create meaningful bundles for efficient context management and LLM consumption.
+
+## Goals
+
+- Analyze project structure and identify logical file groupings
+- Create bundles that reflect the project's architecture and workflow
+- Establish bundle naming conventions and categorization rules
+- Set up automated bundle suggestions for future file additions
+- Document bundle purposes and contents for team understanding
+
+## User Stories
+
+- As a developer, I want an agent to analyze my codebase so that I can understand how to organize files into logical bundles
+- As a developer, I want suggested bundle structures so that I don't have to manually categorize every file
+- As a team member, I want clear bundle documentation so that I understand the project organization
+- As a developer, I want bundle rules that adapt to my project so that new files are automatically categorized appropriately
+
+## Functional Requirements
+
+1. The system must analyze the existing project structure and file types
+2. The system must suggest logical bundle groupings based on project architecture
+3. The system must create bundle configuration files with clear naming and descriptions
+4. **CRITICAL**: The system must update .cntx/bundle-states.json as the single source of truth for bundle definitions
+5. The system must establish rules for automatic file categorization
+6. The system must generate documentation explaining each bundle's purpose
+7. The system must allow iterative refinement of bundle structure based on user feedback
+8. The system must integrate with the existing cntx-ui bundle management system
+
+## Non-Goals (Out of Scope)
+
+- Modifying existing project files or structure
+- Creating complex custom bundling algorithms
+- Handling projects with unusual or highly specialized architectures
+- Setting up advanced semantic analysis beyond basic file categorization
+
+## Design Considerations
+
+- Follow existing cntx-ui bundle configuration patterns
+- Use clear, intuitive bundle names that reflect project concepts
+- Consider both technical structure (frontend/backend) and functional structure (features/components)
+- Balance bundle granularity - not too many small bundles, not too few large ones
+- Account for common development workflows and contexts
+
+## Technical Considerations
+
+- Leverage existing cntx-ui bundle management and configuration systems
+- Use file path analysis and naming patterns for initial categorization
+- Consider integration with semantic analysis for content-based grouping
+- Ensure bundle configurations are easily editable and maintainable
+- Account for different project types (React, Node.js, full-stack, etc.)
+
+## Success Metrics
+
+- Complete bundle coverage of project files with logical groupings
+- Clear bundle documentation that team members can understand
+- Automated bundle suggestions that are 80%+ accurate for new files
+- Reduced time to find relevant files when working on specific features
+- Improved context efficiency when using bundled files with LLMs
+
+## Open Questions
+
+- What level of bundle granularity works best for different project sizes?
+- How should bundles handle cross-cutting concerns like utilities and shared components?
+- Should bundles be organized by technical layers or business features?
+- How can bundle rules adapt as the project evolves?
+
+## Status
+
+- **Current Status**: Todo
+- **Priority**: High
+- **Estimated Effort**: Small
+- **Dependencies**: Existing cntx-ui bundle management system
+
+## Related Files
+
+- `.cntx/config.json` - Non-bundle configuration settings (editor, etc.)
+- `.cntx/bundle-states.json` - Single source of truth for all bundle definitions
+- `lib/bundle-manager.js` - Bundle management logic
+- `lib/configuration-manager.js` - Configuration and bundle state management
+- `web/src/components/BundleList.tsx` - Bundle UI components

package/templates/activities/activities/create-project-bundles/notes.md

@@ -0,0 +1,98 @@
+# Notes: Create Project Bundles with Agent Assistance
+
+## Overview
+
+This document captures ongoing thoughts, insights, and reference information related to creating project bundles with agent assistance.
+
+## Agent Collaboration Tips
+
+### Effective Prompts for Bundle Creation
+- "Analyze my project structure and suggest logical file groupings"
+- "Help me understand which files should be bundled together for [specific feature/workflow]"
+- "Review these bundle suggestions and recommend improvements"
+- "Create bundle rules that will automatically categorize files like [example files]"
+
+### Questions to Ask Your Agent
+- What architectural patterns do you see in this codebase?
+- How would you group these files for efficient context switching?
+- What bundle structure would work best for a team of [X] developers?
+- Can you suggest rules for automatically categorizing new files?
+
+## Bundle Strategy Notes
+
+### Common Bundle Patterns
+- **By Architecture Layer:** frontend, backend, database, api
+- **By Feature:** user-auth, payment-system, dashboard, reports  
+- **By Component Type:** ui-components, pages, hooks, utilities
+- **By Development Phase:** core, features, testing, deployment
+
+### Bundle Naming Guidelines
+- Use clear, descriptive names that reflect content
+- Avoid technical jargon that team members might not understand
+- Consider using consistent prefixes (ui-, api-, lib-, etc.)
+- Keep names short but meaningful
+
+## Project-Specific Considerations
+
+### Codebase Characteristics
+_Document specific aspects of your project that affect bundle organization_
+
+### Team Workflow
+_Note how your team works with files and what bundle structure would support their workflow_
+
+### Future Growth
+_Consider how bundle structure should accommodate project expansion_
+
+## Reference Examples
+
+### Sample Bundle Configurations
+
+**bundle-states.json** (single source of truth):
+```json
+[
+  {
+    "name": "ui-components",
+    "patterns": ["src/components/**/*.tsx", "src/ui/**/*.tsx"],
+    "files": ["src/components/Button.tsx", "src/ui/Card.tsx"],
+    "content": "",
+    "size": 45231,
+    "changed": false,
+    "generated": "2025-06-30T08:00:00.000Z"
+  }
+]
+```
+
+**config.json** (non-bundle settings only):
+```json
+{
+  "editor": "cursor"
+}
+```
+
+⚠️ **CRITICAL**: Use .cntx/bundle-states.json as the single source of truth for all bundle data!
+
+### File Organization Patterns
+- Component files: Component.tsx, Component.test.tsx, Component.stories.tsx
+- Page files: pages/[route]/index.tsx, pages/[route]/components/
+- API files: api/[endpoint]/route.ts, api/[endpoint]/types.ts
+
+## Useful Commands
+
+### Analyzing Project Structure
+```bash
+# Get overview of project structure
+tree -I 'node_modules|dist|build' -L 3
+
+# Count files by type
+find . -name "*.tsx" | wc -l
+find . -name "*.ts" | wc -l
+```
+
+### Bundle Testing
+```bash
+# Test bundle generation
+cntx-ui bundle --name ui-components --dry-run
+
+# View bundle contents
+cntx-ui status --verbose
+```

package/templates/activities/activities/create-project-bundles/progress.md

@@ -0,0 +1,63 @@
+# Progress Tracking: Create Project Bundles with Agent Assistance
+
+## Current Status: Todo
+
+**Last Updated:** Not started  
+**Next Action:** Begin project analysis and discovery phase
+
+## Completed Tasks
+
+_No tasks completed yet_
+
+## In Progress Tasks
+
+_No tasks currently in progress_
+
+## Upcoming Tasks
+
+- [ ] 1.0 Project Analysis and Discovery
+- [ ] 2.0 Bundle Strategy Design  
+- [ ] 3.0 Bundle Configuration Implementation
+- [ ] 4.0 Documentation and Refinement
+
+## Notes and Decisions
+
+### Key Decisions Made
+_Document important decisions as they are made during the activity_
+
+### Challenges Encountered
+_Track any obstacles or issues that arise during implementation_
+
+### Lessons Learned
+_Capture insights gained during the bundle creation process_
+
+## Agent Interaction Log
+
+### Session 1: [Date]
+_Example format for documenting agent interactions:_
+- **User Request:** "Help me analyze my React project structure"
+- **Agent Analysis:** [Agent's findings about project structure]
+- **User Feedback:** [User's response to agent suggestions]
+- **Outcome:** [What was decided or implemented]
+
+### Session 2: [Date]
+_Continue logging agent interactions for future reference_
+
+## Bundle Evolution
+
+### Initial Structure
+_Document the first bundle configuration created_
+
+### Refinements Made
+_Track changes made to bundle structure based on usage and feedback_
+
+### Current Configuration
+_Maintain current state of bundle setup_
+
+## Success Metrics Progress
+
+- [ ] Complete bundle coverage of project files
+- [ ] Clear bundle documentation created
+- [ ] Automated bundle suggestions implemented
+- [ ] Team can easily understand and use bundle system
+- [ ] Improved context efficiency demonstrated

package/templates/activities/activities/create-project-bundles/tasks.md

@@ -0,0 +1,39 @@
+## Relevant Files
+
+- `.cntx/config.json` - Non-bundle configuration settings (editor preferences, etc.)
+- `.cntx/bundle-states.json` - Single source of truth for all bundle definitions and metadata
+- `lib/bundle-manager.js` - Core bundle management logic for processing and applying bundle rules
+- `web/src/components/BundleList.tsx` - UI component for displaying and managing bundles
+- `web/src/components/BundleDetails.tsx` - UI component for viewing individual bundle contents
+- `lib/heuristics-manager.js` - Logic for automatic file categorization and bundle suggestions
+
+### Notes
+
+- This activity focuses on configuration and setup rather than code changes
+- The agent will primarily work with JSON configuration files and provide guidance
+- Bundle rules should be tested with sample files to ensure they work correctly
+- Documentation should be clear enough for team members to understand and modify bundles
+
+## Tasks
+
+- [ ] 1.0 Project Analysis and Discovery
+  - [ ] 1.1 Analyze project directory structure and identify main folders/modules
+  - [ ] 1.2 Categorize existing files by type, purpose, and architectural layer
+  - [ ] 1.3 Identify common patterns in file naming and organization
+  - [ ] 1.4 Document project architecture and workflow patterns
+- [ ] 2.0 Bundle Strategy Design
+  - [ ] 2.1 Propose initial bundle structure based on project analysis
+  - [ ] 2.2 Define bundle naming conventions and categorization rules
+  - [ ] 2.3 Create bundle descriptions that explain their purpose and contents
+  - [ ] 2.4 Validate bundle strategy with user and refine based on feedback
+- [ ] 3.0 Bundle Configuration Implementation
+  - [ ] 3.1 Create bundle definitions in .cntx/bundle-states.json with patterns and metadata
+  - [ ] 3.2 **CRITICAL**: Use .cntx/bundle-states.json as single source of truth (no config.json bundle data)
+  - [ ] 3.3 Set up automatic file categorization rules
+  - [ ] 3.4 Configure bundle metadata (descriptions, tags, priorities)
+  - [ ] 3.5 Test bundle rules with sample files to ensure proper categorization
+- [ ] 4.0 Documentation and Refinement
+  - [ ] 4.1 Document bundle purposes and use cases for team reference
+  - [ ] 4.2 Create guidelines for adding new bundles or modifying existing ones
+  - [ ] 4.3 Test bundle system with real project workflow scenarios
+  - [ ] 4.4 Refine bundle structure based on usage patterns and feedback

package/templates/activities/activities.json

@@ -0,0 +1,219 @@
+[
+  {
+    "title": "Create Project Bundles with Agent Assistance",
+    "description": "Set up organized bundles for a new codebase using agent assistance to analyze project structure and suggest appropriate file groupings.",
+    "desired_outcome": "Complete bundle coverage with logical groupings, clear documentation, and automated suggestions for new files. Improved context efficiency for LLM consumption.",
+    "references": [
+      ".cntx/activities/activities/create-project-bundles/README.md",
+      ".cntx/activities/activities/create-project-bundles/tasks.md",
+      ".cntx/activities/activities/create-project-bundles/progress.md"
+    ],
+    "status": "todo",
+    "tags": ["bundles", "agent-collaboration", "setup"],
+    "tasks": [
+      {
+        "title": "Project Analysis and Discovery",
+        "description": "Analyze project directory structure and identify main folders, file types, and architectural patterns.",
+        "status": "todo"
+      },
+      {
+        "title": "Bundle Strategy Design",
+        "description": "Propose initial bundle structure based on project analysis and define naming conventions.",
+        "status": "todo"
+      },
+      {
+        "title": "Bundle Configuration Implementation",
+        "description": "Create bundle definitions in .cntx/bundle-states.json and set up automatic file categorization rules.",
+        "status": "todo"
+      },
+      {
+        "title": "Documentation and Refinement",
+        "description": "Document bundle purposes, create usage guidelines, and refine structure based on testing.",
+        "status": "todo"
+      }
+    ]
+  },
+  {
+    "title": "API Audit, Refinement, and Documentation",
+    "description": "Review all existing API endpoints, refine their design for consistency and efficiency, and generate comprehensive documentation.",
+    "desired_outcome": "All API endpoints are consistent, efficient, and well-documented. API documentation is up-to-date and easily accessible.",
+    "references": [
+      ".cntx/activities/activities/api-audit/README.md",
+      ".cntx/activities/activities/api-audit/tasks.md",
+      ".cntx/activities/activities/api-audit/progress.md"
+    ],
+    "status": "todo",
+    "tags": ["general", "api"],
+    "tasks": [
+      {
+        "title": "Example",
+        "description": "lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+        "status": "todo"
+      }
+    ]
+  },
+  {
+    "title": "Agent Stories: Research and Optimization",
+    "description": "Create a comprehensive research activity to systematically test and discover optimal patterns for agent interactions with cntx-ui through the .cntx directory and MCP server.",
+    "desired_outcome": "Comprehensive coverage of agent interaction scenarios, documented best practices, and an actionable plan for continuous agent testing through the 'Agent Stories Cycle'.",
+    "references": [
+      ".cntx/activities/activities/agent-stories/README.md",
+      ".cntx/activities/activities/agent-stories/tasks.md",
+      ".cntx/activities/activities/agent-stories/progress.md"
+    ],
+    "status": "todo",
+    "tags": ["general", "agent"],
+    "tasks": [
+      {
+        "title": "Current State Analysis",
+        "description": "Analyze existing agent instructions, MCP server tools, and interaction patterns.",
+        "status": "todo"
+      }
+    ]
+  },
+  {
+    "title": "Heuristics Configuration Refactor",
+    "description": "Transform hardcoded heuristics into a configurable, agent-manageable system. Extract all code categorization logic into centralized configuration with agent activity framework integration.",
+    "desired_outcome": "All heuristics are externalized to configuration, agents can automatically refine categorization rules, and the system maintains complete backward compatibility while enabling intelligent self-improvement.",
+    "references": [
+      ".cntx/activities/activities/heuristics-refactor/README.md"
+    ],
+    "status": "todo",
+    "tags": ["general", "refactor"],
+    "tasks": [
+      {
+        "title": "Extract Purpose Detection Heuristics",
+        "description": "Extract hardcoded purpose detection patterns from semantic-splitter.js to heuristics-config.json",
+        "status": "todo"
+      },
+      {
+        "title": "Extract Bundle Suggestion Logic",
+        "description": "Extract bundle suggestion heuristics from BundleList.tsx to centralized config",
+        "status": "todo"
+      },
+      {
+        "title": "Create HeuristicsManager Service",
+        "description": "Build centralized service for loading and applying heuristics with caching and validation",
+        "status": "todo"
+      },
+      {
+        "title": "Implement Heuristics API Endpoints",
+        "description": "Create REST API for reading, updating, and managing heuristics configuration",
+        "status": "todo"
+      },
+      {
+        "title": "Build Agent Activity Framework",
+        "description": "Implement activity scheduler and execution system for agent-driven heuristics refinement",
+        "status": "todo"
+      },
+      {
+        "title": "Verify Backward Compatibility",
+        "description": "Ensure all existing functionality works identically after refactor",
+        "status": "todo"
+      }
+    ]
+  },
+  {
+    "title": "VS Code Extension",
+    "description": "Adapt the existing cntx-ui tool into a VS Code extension, providing an integrated experience within the editor.",
+    "desired_outcome": "A functional VS Code extension that embeds the cntx-ui, allowing users to manage their projects without leaving the editor. The extension will share a codebase with the standalone web application.",
+    "references": [
+      ".cntx/activities/activities/vscode-extension/README.md",
+      ".cntx/activities/activities/vscode-extension/tasks.md",
+      ".cntx/activities/activities/vscode-extension/progress.md"
+    ],
+    "status": "todo",
+    "tags": ["vscode", "feature"],
+    "tasks": [
+      {
+        "title": "Project Scaffolding",
+        "description": "Set up the basic file structure for a VS Code extension, including package.json, extension.ts, and a webpack.config.js.",
+        "status": "todo"
+      },
+      {
+        "title": "Implement Webview Panel",
+        "description": "Create the command and logic to open a WebviewPanel that loads the existing web/dist/index.html.",
+        "status": "todo"
+      },
+      {
+        "title": "Create Communication Bridge",
+        "description": "Develop an abstraction layer that handles messaging between the webview and the extension host, supporting both postMessage and WebSockets.",
+        "status": "todo"
+      },
+      {
+        "title": "Implement Activation Events",
+        "description": "Configure the extension to activate when a .cntx directory is found, when the Activity Bar icon is clicked, or when a command is run.",
+        "status": "todo"
+      },
+      {
+        "title": "Add Activity Bar Icon",
+        "description": "Create an icon for the extension and configure it to appear in the VS Code Activity Bar.",
+        "status": "todo"
+      },
+      {
+        "title": "Implement Command Palette Actions",
+        "description": "Add the cntx-ui: Start Server, cntx-ui: Stop Server, and cntx-ui: Open UI commands to the Command Palette.",
+        "status": "todo"
+      },
+      {
+        "title": "Build Initial Dashboard UI",
+        "description": "Create the simple dashboard view with controls for the server, a health status indicator, and a list of bundles.",
+        "status": "todo"
+      },
+      {
+        "title": "Backend Integration",
+        "description": "Connect the dashboard UI to the reused backend logic to control the server and fetch the bundle list.",
+        "status": "todo"
+      },
+      {
+        "title": "Documentation",
+        "description": "Update the project's README.md with instructions on how to build, run, and debug the new VS Code extension.",
+        "status": "todo"
+      },
+      {
+        "title": "Packaging and Testing",
+        "description": "Create a .vsix package for the extension and test its installation and functionality in a clean VS Code environment.",
+        "status": "todo"
+      }
+    ]
+  },
+  {
+    "title": "cntx-ui Init Defaults",
+    "description": "Define and implement a comprehensive default template for the .cntx directory, established by `cntx-ui init`.",
+    "desired_outcome": "A single command initializes a fully functional .cntx directory with all necessary defaults, compatible with the UI.",
+    "references": [
+      ".cntx/activities/activities/cntx-ui-init-defaults/README.md",
+      ".cntx/activities/activities/cntx-ui-init-defaults/tasks.md",
+      ".cntx/activities/activities/cntx-ui-init-defaults/progress.md"
+    ],
+    "status": "todo",
+    "tags": ["init", "defaults", "scaffolding"],
+    "tasks": [
+      {
+        "title": "Define Default .cntx Structure & Content",
+        "description": "Create templates for config, hidden-files, semantic-cache, activities, and agent-rules.",
+        "status": "todo"
+      },
+      {
+        "title": "Extend Existing cntx-ui init Command",
+        "description": "Modify the `init` command to copy the default .cntx structure to the user's project.",
+        "status": "todo"
+      },
+      {
+        "title": "Integrate Minimal Default Activities & Agent Rules",
+        "description": "Ensure the sample activities and agent rules are correctly loaded and displayed.",
+        "status": "todo"
+      },
+      {
+        "title": "Testing & Validation",
+        "description": "Write tests for the `init` command and verify the created .cntx directory.",
+        "status": "todo"
+      },
+      {
+        "title": "Documentation & Release Preparation",
+        "description": "Update documentation and prepare for release of the new `init` functionality.",
+        "status": "todo"
+      }
+    ]
+  }
+]

package/templates/activities/lib/.markdownlint.jsonc

@@ -0,0 +1,18 @@
+{
+  // https://github.com/markdownlint/markdownlint/blob/main/docs/RULES.md
+  "default": true,
+  // Trailing spaces
+  "MD009": false,
+  // Line length (default: 80)
+  "MD013": false,
+  // Duplicate headings (e.g., nested headings)
+  "MD024": false,
+  // Ordered list item prefix
+  "MD029": {
+    "style": "ordered"
+  },
+  // Fenced code blocks should be surrounded by blank lines
+  "MD031": false,
+  // Emphasis as heading (e.g., table of contents)
+  "MD036": false
+}