cntx-ui 2.0.13 → 2.0.15

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,83 @@
+# 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 both .cntx/bundles.json (metadata) AND .cntx/config.json (tracking patterns)
+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` - Main cntx-ui configuration
+- `.cntx/bundles.json` - Bundle definitions and rules
+- `lib/bundle-manager.js` - Bundle management logic
+- `web/src/components/BundleList.tsx` - Bundle UI components

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

@@ -0,0 +1,102 @@
+# 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
+
+**bundles.json** (detailed metadata):
+```json
+{
+  "name": "ui-components",
+  "description": "Reusable UI components and design system elements",
+  "patterns": ["src/components/**/*.tsx", "src/ui/**/*.tsx"],
+  "exclude": ["**/*.test.tsx", "**/*.stories.tsx"],
+  "tags": ["ui", "components"],
+  "priority": 1
+}
+```
+
+**config.json** (tracking patterns):
+```json
+{
+  "bundles": {
+    "ui-components": [
+      "src/components/**/*.tsx",
+      "src/ui/**/*.tsx",
+      "!**/*.test.tsx",
+      "!**/*.stories.tsx"
+    ]
+  }
+}
+```
+
+⚠️ **CRITICAL**: Both files must be updated for bundles to appear in the UI!
+
+### 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` - Main configuration file that will be updated with bundle settings
+- `.cntx/bundles.json` - Bundle definitions file that will contain all bundle configurations
+- `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/bundles.json with detailed metadata
+  - [ ] 3.2 **CRITICAL**: Update .cntx/config.json with bundle patterns for tracking
+  - [ ] 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/bundles.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
+}

package/templates/activities/lib/create-activity.mdc

@@ -0,0 +1,63 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Rule: Generating an Activity Definition
+
+## Goal
+
+To guide an AI assistant in creating a detailed Activity Definition in Markdown format, based on an initial user prompt. The Activity should be clear, actionable, and suitable for a junior developer to understand and implement the feature or improvement for the cntx-ui project.
+
+## Process
+
+1.  **Receive Initial Prompt:** The user provides a brief description or request for a new feature, improvement, or functionality for cntx-ui.
+2.  **Ask Clarifying Questions:** Before writing the Activity, the AI *must* ask clarifying questions to gather sufficient detail. The goal is to understand the "what" and "why" of the activity, not necessarily the "how" (which the developer will figure out). Make sure to provide options in letter/number lists so I can respond easily with my selections.
+3.  **Generate Activity:** Based on the initial prompt and the user's answers to the clarifying questions, generate an Activity using the structure outlined below.
+4.  **Save Activity:** Save the generated document as `activity-[feature-name].md` inside the `.cntx/activities/[activity-name]/` directory.
+
+## Clarifying Questions (Examples)
+
+The AI should adapt its questions based on the prompt, but here are some common areas to explore:
+
+*   **Problem/Goal:** "What problem does this activity solve for cntx-ui users?" or "What is the main goal we want to achieve with this activity?"
+*   **Target User:** "Who is the primary user of this feature? (e.g., developers using cntx-ui, AI assistants, end users of bundled applications)"
+*   **Core Functionality:** "Can you describe the key actions a user should be able to perform with this feature?"
+*   **User Stories:** "Could you provide a few user stories? (e.g., As a [type of user], I want to [perform an action] so that [benefit].)"
+*   **Acceptance Criteria:** "How will we know when this activity is successfully implemented? What are the key success criteria?"
+*   **Scope/Boundaries:** "Are there any specific things this activity *should not* do (non-goals)?"
+*   **Data Requirements:** "What kind of data does this feature need to display or manipulate? (e.g., bundle configurations, file metadata, semantic chunks)"
+*   **Design/UI:** "Are there any existing design patterns in cntx-ui to follow?" or "Can you describe the desired look and feel?"
+*   **Edge Cases:** "Are there any potential edge cases or error conditions we should consider?"
+
+## Activity Structure
+
+The generated Activity should include the following sections:
+
+1.  **Introduction/Overview:** Briefly describe the activity and the problem it solves for cntx-ui. State the goal.
+2.  **Goals:** List the specific, measurable objectives for this activity.
+3.  **User Stories:** Detail the user narratives describing activity usage and benefits.
+4.  **Functional Requirements:** List the specific functionalities the activity must have. Use clear, concise language (e.g., "The system must allow users to configure bundle rules."). Number these requirements.
+5.  **Non-Goals (Out of Scope):** Clearly state what this activity will *not* include to manage scope.
+6.  **Design Considerations (Optional):** Link to existing UI components, describe UI/UX requirements, or mention relevant cntx-ui components/styles if applicable.
+7.  **Technical Considerations (Optional):** Mention any known technical constraints, dependencies, or suggestions (e.g., "Should integrate with the existing bundle management system").
+8.  **Success Metrics:** How will the success of this activity be measured? (e.g., "Improve bundle generation speed by 20%", "Reduce configuration errors by 50%").
+9.  **Open Questions:** List any remaining questions or areas needing further clarification.
+
+## Target Audience
+
+Assume the primary reader of the Activity is a **junior developer** working on cntx-ui. Therefore, requirements should be explicit, unambiguous, and avoid jargon where possible. Provide enough detail for them to understand the activity's purpose and core logic.
+
+## Output
+
+*   **Format:** Markdown (`.md`)
+*   **Location:** `.cntx/activities/activities/[activity-name]/`
+*   **Filename:** `README.md`
+
+## Final instructions
+
+1. Do NOT start implementing the Activity
+2. Make sure to ask the user clarifying questions
+3. Take the user's answers to the clarifying questions and improve the Activity
+4. Consider how this activity fits into the broader cntx-ui ecosystem of file bundling and AI development tools
+5. **REQUIRED**: After creating the activity README.md, update `.cntx/activities/activities.json` to register the new activity with proper title, description, desired_outcome, references, status, and tasks