contextly 0.1.4__tar.gz → 1.0.0__tar.gz

contextly-1.0.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: contextly
+Version: 1.0.0
+Summary: The ultimate context-engineering workspace CLI for LLMs.
+Author: Contextly Team
+Project-URL: Homepage, https://github.com/vutikurishanmukha9/Contextly
+Project-URL: Repository, https://github.com/vutikurishanmukha9/Contextly.git
+Project-URL: Changelog, https://github.com/vutikurishanmukha9/Contextly/blob/main/cli/CHANGELOG.md
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pathspec>=0.12.0
+Requires-Dist: pyperclip>=1.8.2
+Requires-Dist: tomli>=2.0.1
+Requires-Dist: tiktoken>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+
+# Context-Ly
+
+**Imagine trying to hire a new employee, but instead of giving them an employee handbook, a map of the office, and a list of company rules, you just dump 10,000 loose papers on their desk and say, "figure it out."** 
+
+That is how most people use AI today. They dump raw files into ChatGPT or Claude and hope for the best. The AI gets confused, makes mistakes, and wastes time.
+
+**Context-Ly fixes this.** 
+
+Context-Ly is a tool that automatically reads your project, figures out your unwritten rules, maps out how everything is connected, and packages it perfectly for AI. When you use Context-Ly, the AI instantly understands your project exactly like a senior engineer would—saving you hours of typing, explaining, and correcting.
+
+---
+
+## Overview
+
+Modern AI applications often suffer from "token waste" - providing either too little context (requiring repeated clarifications) or too much irrelevant context (diluting the model's focus). Context-Ly solves this by introducing a structured methodology for building context packs. 
+
+The application sits between the user's raw thoughts and the AI model, enforcing best practices in prompt engineering through an intuitive interface and a real-time heuristic scoring engine.
+
+## Core Features
+
+### 1. Context Builder
+The Context Builder allows users to break down their prompts into distinct, manageable blocks:
+- **Goal**: The primary objective or task (What does success look like?).
+- **Background**: Necessary prerequisite information for the model.
+- **Constraints**: Strict boundaries, desired tone, and format restrictions.
+- **Examples**: Few-shot examples, gold standards, or anti-examples to guide the model.
+- **Files**: Supporting reference materials such as code snippets or documentation.
+
+### 2. Real-Time Context Scoring
+Every context pack is graded algorithmically before it touches an LLM. The scoring engine evaluates the context across four axes:
+- **Relevance**: Analyzes the word overlap ratio between the Goal block and all supporting blocks to ensure every token serves the primary objective.
+- **Completeness**: Verifies the presence of necessary structural components (e.g., heavily penalizing the absence of a defined Goal or Constraints).
+- **Redundancy**: Utilizes Jaccard similarity to detect and penalize repetitive information across different blocks.
+- **Clarity**: Evaluates sentence complexity (penalizing average sentence lengths over 25 words) and detects the excessive use of ambiguous pronouns ("it", "that", "those").
+
+### 3. Prompt Generator
+The generator compiles the active context blocks into a clean, markdown-structured system prompt. It clearly separates the permanent system context (Audience, Tech Stack, Output Style) from the temporary task context, ensuring the output is perfectly formatted for direct integration into tools like ChatGPT, Claude, or API requests.
+
+## Technical Architecture
+
+The application is designed with strict separation of concerns, ensuring that the core business logic remains framework-agnostic. 
+
+- **Frontend Framework**: React with TanStack Start
+- **Styling**: Tailwind CSS and Radix UI (Shadcn components)
+- **State Management**: Zustand with `localStorage` persistence module
+- **Core Engine**: Pure TypeScript logic (`scoring.ts` and `prompt-generator.ts`) completely decoupled from the DOM and React ecosystem, ensuring straightforward migration to alternative interfaces (such as a CLI) in the future.
+
+## Local Development
+
+The web application resides entirely within the `frontend` directory.
+
+### Prerequisites
+- Node.js (v20 or higher recommended)
+- npm
+
+### Installation
+
+1. Clone the repository and navigate to the frontend directory:
+   ```bash
+   cd frontend
+   ```
+
+2. Install the project dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Start the development server:
+   ```bash
+   npm run dev
+   ```
+
+4. Open your browser and navigate to the provided local address (typically `http://localhost:5173`).
+
+## Project Structure
+
+```text
+frontend/
+├── src/
+│   ├── components/      # Reusable UI components (AppShell, Canvas, Optimizer)
+│   ├── lib/
+│   │   ├── prompt-generator.ts  # Logic for formatting the final markdown prompt
+│   │   ├── scoring.ts           # Heuristic mathematical scoring engine
+│   │   └── store.ts             # Zustand state management and persistence
+│   └── routes/          # TanStack Start routing layer
+```
+
+## Context-Ly CLI: The Intelligence Layer
+
+The true value of Context-Ly lies in its command-line interface, which transforms the tool from a simple prompt formatter into a persistent **Context Memory Layer** for your entire repository.
+
+The CLI acts as a static analysis tool that discovers team conventions, evaluates repository complexity, and generates highly-optimized, token-efficient system prompts (`PROJECT_CONTEXT.md`) tailored to your exact stack.
+
+### Setup
+
+To begin using the CLI, activate the Python virtual environment located in the `cli` directory:
+
+```bash
+cd cli
+.\venv\Scripts\activate
+```
+
+### Commands
+
+#### 1. `contextly init`
+Initializes Context-as-Code in the current directory. It creates a `.contextly` configuration folder and sets up your environment.
+
+#### 2. `contextly analyze`
+The ultimate context generator. This command automatically:
+- Reads your `README.md`.
+- Scans your entire project tree to build an ASCII architecture map.
+- Inspects your dependencies to determine your language and framework (e.g. TypeScript, React).
+- Pulls in both manually saved rules and statically inferred conventions.
+- Merges everything into a massive, LLM-ready system prompt named `PROJECT_CONTEXT.md`.
+
+#### 3. `contextly discover`
+Runs the Pattern Discovery Engine. It statically analyzes the codebase using dependency heuristics and file-tree structures to figure out your team's unwritten conventions (e.g. "Uses Zustand", "Uses TailwindCSS", "Service Layer Hint").
+
+#### 4. `contextly learn --auto`
+The interactive gatekeeper to the True Memory Engine. It triggers the Discovery Engine and interactively asks if you want to save the discovered conventions:
+```text
+Save convention: TailwindCSS (Uses TailwindCSS for styling.)? [y/N]
+```
+Confirmed conventions are saved permanently to `.contextly/memory/rules.yaml`.
+
+#### 5. `contextly memory`
+Trust requires visibility. Use this command to inspect all rules and conventions that have been permanently saved to the project's memory.
+
+#### 6. `contextly pack <dir>`
+Bundles a specific directory (e.g., `src/components`) into an LLM-ready Context Pack. It reads all files, counts their tokens, and bundles them into `.contextly/packs/` so you can effortlessly copy-paste large portions of your codebase into an LLM without clutter.
+
+#### 7. `contextly inspect`
+Performs a deep-dive analysis on your repository complexity, warning you about excessively large files that will act as "Token Hogs" and consume too much context window.
+
+---
+
+## Changelog
+
+For all release notes and version history, please see the [CHANGELOG.md](CHANGELOG.md).

contextly-1.0.0/README.md

@@ -0,0 +1,139 @@
+# Context-Ly
+
+**Imagine trying to hire a new employee, but instead of giving them an employee handbook, a map of the office, and a list of company rules, you just dump 10,000 loose papers on their desk and say, "figure it out."** 
+
+That is how most people use AI today. They dump raw files into ChatGPT or Claude and hope for the best. The AI gets confused, makes mistakes, and wastes time.
+
+**Context-Ly fixes this.** 
+
+Context-Ly is a tool that automatically reads your project, figures out your unwritten rules, maps out how everything is connected, and packages it perfectly for AI. When you use Context-Ly, the AI instantly understands your project exactly like a senior engineer would—saving you hours of typing, explaining, and correcting.
+
+---
+
+## Overview
+
+Modern AI applications often suffer from "token waste" - providing either too little context (requiring repeated clarifications) or too much irrelevant context (diluting the model's focus). Context-Ly solves this by introducing a structured methodology for building context packs. 
+
+The application sits between the user's raw thoughts and the AI model, enforcing best practices in prompt engineering through an intuitive interface and a real-time heuristic scoring engine.
+
+## Core Features
+
+### 1. Context Builder
+The Context Builder allows users to break down their prompts into distinct, manageable blocks:
+- **Goal**: The primary objective or task (What does success look like?).
+- **Background**: Necessary prerequisite information for the model.
+- **Constraints**: Strict boundaries, desired tone, and format restrictions.
+- **Examples**: Few-shot examples, gold standards, or anti-examples to guide the model.
+- **Files**: Supporting reference materials such as code snippets or documentation.
+
+### 2. Real-Time Context Scoring
+Every context pack is graded algorithmically before it touches an LLM. The scoring engine evaluates the context across four axes:
+- **Relevance**: Analyzes the word overlap ratio between the Goal block and all supporting blocks to ensure every token serves the primary objective.
+- **Completeness**: Verifies the presence of necessary structural components (e.g., heavily penalizing the absence of a defined Goal or Constraints).
+- **Redundancy**: Utilizes Jaccard similarity to detect and penalize repetitive information across different blocks.
+- **Clarity**: Evaluates sentence complexity (penalizing average sentence lengths over 25 words) and detects the excessive use of ambiguous pronouns ("it", "that", "those").
+
+### 3. Prompt Generator
+The generator compiles the active context blocks into a clean, markdown-structured system prompt. It clearly separates the permanent system context (Audience, Tech Stack, Output Style) from the temporary task context, ensuring the output is perfectly formatted for direct integration into tools like ChatGPT, Claude, or API requests.
+
+## Technical Architecture
+
+The application is designed with strict separation of concerns, ensuring that the core business logic remains framework-agnostic. 
+
+- **Frontend Framework**: React with TanStack Start
+- **Styling**: Tailwind CSS and Radix UI (Shadcn components)
+- **State Management**: Zustand with `localStorage` persistence module
+- **Core Engine**: Pure TypeScript logic (`scoring.ts` and `prompt-generator.ts`) completely decoupled from the DOM and React ecosystem, ensuring straightforward migration to alternative interfaces (such as a CLI) in the future.
+
+## Local Development
+
+The web application resides entirely within the `frontend` directory.
+
+### Prerequisites
+- Node.js (v20 or higher recommended)
+- npm
+
+### Installation
+
+1. Clone the repository and navigate to the frontend directory:
+   ```bash
+   cd frontend
+   ```
+
+2. Install the project dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Start the development server:
+   ```bash
+   npm run dev
+   ```
+
+4. Open your browser and navigate to the provided local address (typically `http://localhost:5173`).
+
+## Project Structure
+
+```text
+frontend/
+├── src/
+│   ├── components/      # Reusable UI components (AppShell, Canvas, Optimizer)
+│   ├── lib/
+│   │   ├── prompt-generator.ts  # Logic for formatting the final markdown prompt
+│   │   ├── scoring.ts           # Heuristic mathematical scoring engine
+│   │   └── store.ts             # Zustand state management and persistence
+│   └── routes/          # TanStack Start routing layer
+```
+
+## Context-Ly CLI: The Intelligence Layer
+
+The true value of Context-Ly lies in its command-line interface, which transforms the tool from a simple prompt formatter into a persistent **Context Memory Layer** for your entire repository.
+
+The CLI acts as a static analysis tool that discovers team conventions, evaluates repository complexity, and generates highly-optimized, token-efficient system prompts (`PROJECT_CONTEXT.md`) tailored to your exact stack.
+
+### Setup
+
+To begin using the CLI, activate the Python virtual environment located in the `cli` directory:
+
+```bash
+cd cli
+.\venv\Scripts\activate
+```
+
+### Commands
+
+#### 1. `contextly init`
+Initializes Context-as-Code in the current directory. It creates a `.contextly` configuration folder and sets up your environment.
+
+#### 2. `contextly analyze`
+The ultimate context generator. This command automatically:
+- Reads your `README.md`.
+- Scans your entire project tree to build an ASCII architecture map.
+- Inspects your dependencies to determine your language and framework (e.g. TypeScript, React).
+- Pulls in both manually saved rules and statically inferred conventions.
+- Merges everything into a massive, LLM-ready system prompt named `PROJECT_CONTEXT.md`.
+
+#### 3. `contextly discover`
+Runs the Pattern Discovery Engine. It statically analyzes the codebase using dependency heuristics and file-tree structures to figure out your team's unwritten conventions (e.g. "Uses Zustand", "Uses TailwindCSS", "Service Layer Hint").
+
+#### 4. `contextly learn --auto`
+The interactive gatekeeper to the True Memory Engine. It triggers the Discovery Engine and interactively asks if you want to save the discovered conventions:
+```text
+Save convention: TailwindCSS (Uses TailwindCSS for styling.)? [y/N]
+```
+Confirmed conventions are saved permanently to `.contextly/memory/rules.yaml`.
+
+#### 5. `contextly memory`
+Trust requires visibility. Use this command to inspect all rules and conventions that have been permanently saved to the project's memory.
+
+#### 6. `contextly pack <dir>`
+Bundles a specific directory (e.g., `src/components`) into an LLM-ready Context Pack. It reads all files, counts their tokens, and bundles them into `.contextly/packs/` so you can effortlessly copy-paste large portions of your codebase into an LLM without clutter.
+
+#### 7. `contextly inspect`
+Performs a deep-dive analysis on your repository complexity, warning you about excessively large files that will act as "Token Hogs" and consume too much context window.
+
+---
+
+## Changelog
+
+For all release notes and version history, please see the [CHANGELOG.md](CHANGELOG.md).

contextly-1.0.0/contextly/__init__.py

@@ -0,0 +1 @@
+# Contextly CLI Package

contextly-1.0.0/contextly/commands/__init__.py

@@ -0,0 +1 @@
+# Init commands

contextly-1.0.0/contextly/commands/analyze.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+from rich.table import Table
+import typer
+
+from ..utils.console import console
+from ..scanners.base import ScannerError
+from ..utils.exceptions import ContextlyError
+from ..core.analyzer.engine import AnalyzerEngine
+
+def analyze_cmd(model: str = typer.Option("chatgpt", "--model", "-m", help="Target LLM format ('chatgpt' or 'claude')")):
+    """Automatically analyze and map the repository"""
+    root_dir = Path.cwd()
+    engine = AnalyzerEngine(root_dir)
+    
+    with console.status("[bold blue]Scanning repository intelligence (Max Level)...", spinner="dots"):
+        try:
+            intelligence = engine.analyze(model)
+        except ScannerError as e:
+            console.print(f"\n[bold red]Scanner Error:[/bold red] {e}")
+            raise typer.Exit(1)
+        except ContextlyError as e:
+            console.print(f"\n[bold red]Context-Ly Error:[/bold red] {e}")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"\n[bold red]Unexpected Error:[/bold red] {e}")
+            raise typer.Exit(1)
+            
+    console.print("\n[bold green][OK][/bold green] Repository scan complete!\n")
+    
+    table = Table(title="Repository Intelligence (Max Level)", show_header=False, box=None)
+    table.add_column("Category", style="cyan", justify="right")
+    table.add_column("Value", style="magenta")
+    
+    table.add_row("Primary Language", f"[bold]{intelligence.language.primary}[/bold]")
+    table.add_row("Frontend Framework", intelligence.frameworks.frontend)
+    table.add_row("Backend/Tooling", intelligence.frameworks.backend)
+    
+    npm_count = len(intelligence.dependencies.npm)
+    py_count = len(intelligence.dependencies.python)
+    
+    if npm_count > 0:
+        table.add_row("NPM Dependencies", str(npm_count))
+    if py_count > 0:
+        table.add_row("Python Dependencies", str(py_count))
+        
+    console.print(table)
+    console.print()
+    console.print(f"[dim]Generated advanced PROJECT_CONTEXT.md ({model.lower()} format) in current directory.[/dim]")
+

contextly-1.0.0/contextly/commands/discover.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+import typer
+
+from ..utils.console import console
+from ..core.discovery.engine import DiscoveryEngine
+from ..scanners.base import ScannerError
+from ..utils.exceptions import ValidationError, ContextlyError
+from ..utils.validation import require_contextly_initialized
+
+def discover_cmd():
+    """Statically analyze the repository to discover architectural patterns and conventions"""
+    root_dir = Path.cwd()
+    
+    try:
+        require_contextly_initialized(root_dir)
+    except ValidationError as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+        
+    engine = DiscoveryEngine(root_dir)
+        
+    with console.status("[bold blue]Running Pattern Discovery Engine...", spinner="dots"):
+        try:
+            patterns_result = engine.discover()
+        except ScannerError as e:
+            console.print(f"\n[bold red]Scanner Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+        except ContextlyError as e:
+            console.print(f"\n[bold red]Context-Ly Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+        
+    console.print("[bold green][OK][/bold green] Pattern Discovery Complete:\n")
+    
+    if not patterns_result.patterns:
+        console.print("[yellow]No recognizable architectural patterns or conventions discovered.[/yellow]")
+        return
+
+    # Group by category
+    categories = {}
+    for p in patterns_result.patterns:
+        if p.category not in categories:
+            categories[p.category] = []
+        categories[p.category].append(p)
+        
+    for category, patterns in sorted(categories.items()):
+        console.print(f"[bold cyan]{category}:[/bold cyan]")
+        # Sort by confidence descending (High -> Medium -> Low)
+        sorted_patterns = sorted(patterns, key=lambda p: {"high": 0, "medium": 1, "low": 2}.get(p.confidence.lower(), 3))
+        for p in sorted_patterns:
+            console.print(f"  [green]\\[OK][/green] [bold]{p.name}[/bold] ({p.description})")
+        console.print()

contextly-1.0.0/contextly/commands/export.py

@@ -0,0 +1,42 @@
+import typer
+from pathlib import Path
+from ..utils.console import console
+from ..core.exporter.engine import ExporterEngine
+from ..utils.validation import require_contextly_initialized
+from ..utils.exceptions import ValidationError, ContextlyError
+
+def export_cmd(
+    pack_name: str = typer.Argument(..., help="The name of the context pack to export (e.g., 'frontend')")
+):
+    """Fuses intelligence and context packs, copying the result to your clipboard."""
+    root_dir = Path.cwd()
+    
+    try:
+        require_contextly_initialized(root_dir)
+    except ValidationError as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+        
+    engine = ExporterEngine(root_dir)
+    
+    try:
+        export_path, clipboard_success = engine.export(pack_name)
+    except ContextlyError as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+        
+    if clipboard_success:
+        clipboard_status = "[green]Successfully copied to clipboard![/green]"
+    else:
+        clipboard_status = "[yellow]Could not copy to clipboard. The export file was saved successfully.[/yellow]"
+        
+    console.print(f"\n[bold green][OK][/bold green] Export Generation Complete!")
+    console.print(f"  - [cyan]Intelligence:[/cyan] PROJECT_CONTEXT.md")
+    console.print(f"  - [cyan]Context Pack:[/cyan] {pack_name}")
+    console.print(f"  - [cyan]Local Export:[/cyan] {export_path.relative_to(root_dir)}")
+    console.print(f"\n{clipboard_status}")
+    if clipboard_success:
+        console.print("\nYou can now paste the contents directly into Claude or ChatGPT.")
+    else:
+        console.print("\nOpen the local export file to copy the contents manually.")
+

contextly-1.0.0/contextly/commands/init.py

@@ -0,0 +1,24 @@
+import typer
+from pathlib import Path
+from ..utils.console import console
+from ..core.initializer.engine import InitEngine
+from ..utils.exceptions import ContextlyError
+
+def init_cmd():
+    """Initialize Context-as-Code in the current directory"""
+    root_dir = Path.cwd()
+    engine = InitEngine(root_dir)
+    
+    try:
+        success = engine.initialize()
+        if not success:
+            console.print("[yellow]Contextly is already initialized in this repository.[/yellow]")
+            return
+            
+        console.print("[bold green][OK][/bold green] Contextly initialized successfully!")
+        console.print(f"Created configuration at [cyan].contextly/config.yaml[/cyan]")
+        console.print("Edit this file to define your Context-as-Code rules.")
+        
+    except ContextlyError as e:
+        console.print(f"[bold red]Error initializing Contextly:[/bold red] {str(e)}")
+        raise typer.Exit(code=1)

contextly-1.0.0/contextly/commands/inspect.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+from rich.table import Table
+from ..utils.console import console
+from ..utils.exceptions import ValidationError
+from ..utils.validation import require_directory_exists
+from ..core.inspector.engine import InspectorEngine
+import typer
+
+def inspect_cmd():
+    """Deep dive into repository complexity and structure"""
+    try:
+        root_dir = require_directory_exists(str(Path.cwd()))
+    except ValidationError as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+        
+    engine = InspectorEngine(root_dir)
+    
+    with console.status("[bold blue]Inspecting repository file tree...", spinner="bouncingBar"):
+        file_sizes = engine.inspect()
+    
+    console.print("\n[bold green][OK][/bold green] Inspection complete!\n")
+    
+    table = Table(title="Top 5 Largest Files (Potential Token Hogs)")
+    table.add_column("Size (KB)", justify="right", style="cyan")
+    table.add_column("File Path", style="magenta")
+    
+    for size, path in file_sizes[:5]:
+        rel_path = path.relative_to(root_dir)
+        kb_size = size / 1024
+        
+        # Highlight massive files that shouldn't go to LLMs
+        style = "red" if kb_size > 100 else "yellow" if kb_size > 50 else "white"
+        
+        table.add_row(f"{kb_size:.1f}", f"[{style}]{rel_path}[/{style}]")
+        
+    console.print(table)
+    console.print("\n[dim]Tip: Files over 50KB (yellow) or 100KB (red) consume massive LLM context windows. Keep them out of your Context Packs if possible.[/dim]\n")
+

contextly-1.0.0/contextly/commands/learn.py

@@ -0,0 +1,61 @@
+import typer
+from pathlib import Path
+from rich.prompt import Confirm
+from ..utils.console import console
+from ..core.learner.engine import LearnEngine
+from ..scanners.base import ScannerError
+from ..utils.exceptions import ValidationError, ContextlyError
+from ..utils.validation import require_contextly_initialized
+
+def learn_cmd(
+    auto: bool = typer.Option(False, "--auto", help="Automatically discover and interactively learn conventions.")
+):
+    """Teach Context-Ly new conventions, or use --auto to discover them."""
+    root_dir = Path.cwd()
+    try:
+        require_contextly_initialized(root_dir)
+    except ValidationError as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+        
+    engine = LearnEngine(root_dir)
+    
+    if not auto:
+        console.print("[yellow]Manual learning is currently disabled in favor of automated discovery.[/yellow]")
+        console.print("Please use [bold cyan]contextly learn --auto[/bold cyan]")
+        return
+        
+    with console.status("[bold blue]Running Pattern Discovery Engine...", spinner="dots"):
+        try:
+            sorted_patterns = engine.discover_conventions()
+        except ScannerError as e:
+            console.print(f"\n[bold red]Scanner Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+        except ContextlyError as e:
+            console.print(f"\n[bold red]Context-Ly Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+        
+    if not sorted_patterns:
+        console.print("[yellow]No new recognizable conventions discovered to learn.[/yellow]")
+        return
+        
+    console.print("\n[bold green]Discovered Conventions:[/bold green]\n")
+    
+    saved_count = 0
+    for p in sorted_patterns:
+        if Confirm.ask(f"Save convention: [cyan]{p.name}[/cyan] ({p.description})?"):
+            added = engine.save_convention(p)
+            if added:
+                saved_count += 1
+                console.print(f"  [green]\\[OK][/green] Saved to memory.")
+            else:
+                console.print(f"  [dim]Skipped (Already in memory).[/dim]")
+        else:
+            console.print(f"  [dim]Skipped.[/dim]")
+            
+    if saved_count > 0:
+        console.print(f"\n[bold green][OK][/bold green] Successfully saved {saved_count} rules to persistent memory!")
+        console.print("Run [bold cyan]contextly memory[/bold cyan] to view them.")
+    else:
+        console.print("\n[dim]No new rules were saved.[/dim]")
+

contextly-1.0.0/contextly/commands/memory.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+from rich.table import Table
+from ..utils.console import console
+from ..core.memory import MemoryEngine
+from ..utils.exceptions import ValidationError
+from ..utils.validation import require_contextly_initialized
+import typer
+
+def memory_cmd():
+    """Inspect the persistently stored team memory and conventions."""
+    root_dir = Path.cwd()
+    
+    try:
+        require_contextly_initialized(root_dir)
+    except ValidationError as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+        
+    engine = MemoryEngine(root_dir)
+    
+    memory = engine.load_memory()
+    
+    if not memory.rules:
+        console.print("[yellow]Context-Ly memory is currently empty.[/yellow]")
+        console.print("Run [bold cyan]contextly learn --auto[/bold cyan] to discover and save team conventions.")
+        return
+        
+    console.print(f"[bold green]Stored Memory[/bold green] (Found {len(memory.rules)} rules)\n")
+    
+    # Group by category
+    categories = {}
+    for rule in memory.rules:
+        if rule.category not in categories:
+            categories[rule.category] = []
+        categories[rule.category].append(rule)
+        
+    for category, rules in sorted(categories.items()):
+        console.print(f"[bold cyan]{category}[/bold cyan]")
+        # Sort by confidence descending (High -> Medium -> Low)
+        sorted_rules = sorted(rules, key=lambda r: {"high": 0, "medium": 1, "low": 2}.get(r.confidence.lower(), 3))
+        for rule in sorted_rules:
+            source_tag = f"[dim]({rule.source})[/dim]"
+            conf_color = "green" if rule.confidence.lower() == "high" else "yellow"
+            conf_tag = f"[{conf_color}][{rule.confidence}][/{conf_color}]"
+            
+            console.print(f"  - [dim]\\[{rule.id}][/dim] {rule.rule} {conf_tag} {source_tag}")
+        console.print()