cortexcode 0.1.0__py3-none-any.whl

cortexcode/workspace.py

@@ -0,0 +1,180 @@
+"""Multi-repo workspace support - index and query across multiple repositories."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from cortexcode.indexer import CodeIndexer
+
+
+class Workspace:
+    """Manage multiple repositories as a single workspace."""
+    
+    CONFIG_FILE = ".cortexcode-workspace.json"
+    
+    def __init__(self, workspace_root: Path | None = None):
+        self.workspace_root = workspace_root or Path.cwd()
+        self.repos: list[dict[str, Any]] = []
+        self.merged_index: dict[str, Any] = {}
+    
+    def load_config(self) -> bool:
+        """Load workspace config from disk."""
+        config_path = self.workspace_root / self.CONFIG_FILE
+        if not config_path.exists():
+            return False
+        try:
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+            self.repos = data.get("repos", [])
+            return True
+        except (json.JSONDecodeError, OSError):
+            return False
+    
+    def save_config(self) -> None:
+        """Save workspace config to disk."""
+        config_path = self.workspace_root / self.CONFIG_FILE
+        data = {"repos": self.repos}
+        config_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    
+    def add_repo(self, path: str, alias: str | None = None) -> dict:
+        """Add a repository to the workspace."""
+        repo_path = Path(path).resolve()
+        if not repo_path.is_dir():
+            raise ValueError(f"Not a directory: {repo_path}")
+        
+        # Check not already added
+        for r in self.repos:
+            if Path(r["path"]).resolve() == repo_path:
+                raise ValueError(f"Already in workspace: {repo_path}")
+        
+        repo = {
+            "path": str(repo_path),
+            "alias": alias or repo_path.name,
+        }
+        self.repos.append(repo)
+        self.save_config()
+        return repo
+    
+    def remove_repo(self, alias_or_path: str) -> bool:
+        """Remove a repository from the workspace."""
+        resolved = None
+        try:
+            resolved = Path(alias_or_path).resolve()
+        except Exception:
+            pass
+        
+        for i, r in enumerate(self.repos):
+            if r["alias"] == alias_or_path or (resolved and Path(r["path"]).resolve() == resolved):
+                self.repos.pop(i)
+                self.save_config()
+                return True
+        return False
+    
+    def list_repos(self) -> list[dict]:
+        """List all repos in workspace."""
+        result = []
+        for r in self.repos:
+            p = Path(r["path"])
+            index_path = p / ".cortexcode" / "index.json"
+            indexed = index_path.exists()
+            result.append({
+                "alias": r["alias"],
+                "path": r["path"],
+                "indexed": indexed,
+            })
+        return result
+    
+    def index_all(self, incremental: bool = True) -> dict[str, int]:
+        """Index all repos in the workspace. Returns {alias: symbol_count}."""
+        results = {}
+        for r in self.repos:
+            repo_path = Path(r["path"])
+            if not repo_path.is_dir():
+                results[r["alias"]] = -1
+                continue
+            
+            idx = CodeIndexer()
+            index = idx.index_directory(repo_path, incremental=incremental)
+            
+            output_dir = repo_path / ".cortexcode"
+            output_dir.mkdir(exist_ok=True)
+            (output_dir / "index.json").write_text(
+                json.dumps(index, indent=2, default=str), encoding="utf-8"
+            )
+            
+            results[r["alias"]] = len(index.get("symbols", []))
+        
+        return results
+    
+    def get_merged_index(self) -> dict[str, Any]:
+        """Load and merge indices from all repos into a single view."""
+        merged_files = {}
+        merged_call_graph = {}
+        merged_symbols = []
+        merged_file_deps = {}
+        languages = set()
+        
+        for r in self.repos:
+            repo_path = Path(r["path"])
+            index_path = repo_path / ".cortexcode" / "index.json"
+            if not index_path.exists():
+                continue
+            
+            try:
+                index = json.loads(index_path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                continue
+            
+            alias = r["alias"]
+            
+            # Prefix files with repo alias
+            for rel_path, file_data in index.get("files", {}).items():
+                prefixed = f"{alias}/{rel_path}"
+                merged_files[prefixed] = file_data
+            
+            # Merge call graph
+            for caller, callees in index.get("call_graph", {}).items():
+                prefixed_caller = f"{alias}:{caller}"
+                merged_call_graph[prefixed_caller] = [f"{alias}:{c}" for c in callees]
+            
+            # Merge symbols
+            for sym in index.get("symbols", []):
+                sym_copy = dict(sym)
+                if "file" in sym_copy:
+                    sym_copy["file"] = f"{alias}/{sym_copy['file']}"
+                sym_copy["repo"] = alias
+                merged_symbols.append(sym_copy)
+            
+            # Merge file deps
+            for f, deps in index.get("file_dependencies", {}).items():
+                prefixed_f = f"{alias}/{f}"
+                merged_file_deps[prefixed_f] = [f"{alias}/{d}" for d in deps]
+            
+            languages.update(index.get("languages", []))
+        
+        self.merged_index = {
+            "files": merged_files,
+            "call_graph": merged_call_graph,
+            "symbols": merged_symbols,
+            "file_dependencies": merged_file_deps,
+            "languages": sorted(languages),
+            "project_root": str(self.workspace_root),
+            "repos": [r["alias"] for r in self.repos],
+        }
+        return self.merged_index
+    
+    def search_across_repos(self, query: str, max_results: int = 20) -> list[dict]:
+        """Search symbols across all repos."""
+        if not self.merged_index:
+            self.get_merged_index()
+        
+        query_lower = query.lower()
+        results = []
+        
+        for sym in self.merged_index.get("symbols", []):
+            name = sym.get("name", "")
+            if query_lower in name.lower():
+                results.append(sym)
+                if len(results) >= max_results:
+                    break
+        
+        return results

cortexcode-0.1.0.dist-info/METADATA

@@ -0,0 +1,448 @@
+Metadata-Version: 2.4
+Name: cortexcode
+Version: 0.1.0
+Summary: Lightweight code indexing for AI assistants — save 90%+ tokens with structured context
+Author-email: CortexCode <dev@cortexcode.io>
+License: MIT
+Project-URL: Homepage, https://github.com/cortexcode/cortexcode
+Project-URL: Repository, https://github.com/cortexcode/cortexcode
+Project-URL: Documentation, https://github.com/cortexcode/cortexcode#readme
+Project-URL: Issues, https://github.com/cortexcode/cortexcode/issues
+Project-URL: Changelog, https://github.com/cortexcode/cortexcode/blob/main/CHANGELOG.md
+Keywords: code-index,ast,copilot,cursor,rag,ai-assistant,tree-sitter,code-analysis,token-savings,context-provider
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Indexing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tree-sitter>=0.21.0
+Requires-Dist: tree-sitter-python>=0.23.0
+Requires-Dist: tree-sitter-javascript>=0.23.0
+Requires-Dist: tree-sitter-typescript>=0.23.0
+Requires-Dist: tree-sitter-go>=0.23.0
+Requires-Dist: tree-sitter-rust>=0.23.0
+Requires-Dist: tree-sitter-java>=0.23.0
+Requires-Dist: tree-sitter-c-sharp>=0.23.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: watchdog>=4.0.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Provides-Extra: ai
+Requires-Dist: tiktoken>=0.7.0; extra == "ai"
+Provides-Extra: mobile
+Requires-Dist: tree-sitter-kotlin>=0.1.0; extra == "mobile"
+Requires-Dist: tree-sitter-swift>=0.6.0; extra == "mobile"
+Dynamic: license-file
+
+<p align="center">
+  <h1 align="center">CortexCode</h1>
+  <p align="center">
+    <strong>Lightweight code indexing for AI assistants</strong><br>
+    Save 90%+ tokens by giving AI agents structured context instead of raw source files.
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/cortexcode/"><img src="https://img.shields.io/pypi/v/cortexcode?style=flat-square&color=blue" alt="PyPI"></a>
+  <a href="https://pypi.org/project/cortexcode/"><img src="https://img.shields.io/pypi/pyversions/cortexcode?style=flat-square" alt="Python"></a>
+  <a href="https://github.com/cortexcode/cortexcode/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License"></a>
+  <a href="https://github.com/cortexcode/cortexcode"><img src="https://img.shields.io/github/stars/cortexcode/cortexcode?style=flat-square" alt="Stars"></a>
+</p>
+
+---
+
+## The Problem
+
+AI coding assistants (Copilot, Cursor, Windsurf, etc.) need to understand your codebase. The current approach: **dump entire source files into the context window**. This is:
+
+- **Expensive** — A 150-file project can cost 200K+ tokens per query
+- **Slow** — More tokens = slower responses
+- **Wasteful** — Most of those tokens are irrelevant to the question
+
+## The Solution
+
+CortexCode indexes your codebase using **AST parsing** (tree-sitter) and provides a structured, searchable index. Instead of feeding 200K tokens of raw code, you feed **~500 tokens of relevant context**.
+
+```
+┌─────────────────────────────────────────────────┐
+│  Without CortexCode          With CortexCode    │
+│                                                  │
+│  200,000 tokens    →         500 tokens          │
+│  $0.006/query      →         $0.00002/query      │
+│  All files dumped  →         Only relevant syms  │
+│  No structure      →         Call graph + types   │
+└─────────────────────────────────────────────────┘
+```
+
+Run `cortexcode stats` on your project to see your actual savings.
+
+## Quick Start
+
+```bash
+# Install from PyPI
+pip install cortexcode
+
+# Or install from source
+git clone https://github.com/cortexcode/cortexcode.git
+cd cortexcode && pip install -e .
+
+# Index your project
+cd your-project
+cortexcode index
+
+# See token savings
+cortexcode stats
+
+# Get context for AI
+cortexcode context "handleAuth"
+
+# Generate interactive docs
+cortexcode docs --open
+```
+
+## Features
+
+### Multi-Language AST Indexing
+
+Parses source code into structured symbols using tree-sitter grammars.
+
+| Language | Extensions | Frameworks Detected |
+|----------|-----------|-------------------|
+| Python | `.py` | FastAPI, Django |
+| JavaScript | `.js`, `.jsx` | React, Express, Angular |
+| TypeScript | `.ts`, `.tsx` | Next.js, NestJS, Angular |
+| Go | `.go` | — |
+| Rust | `.rs` | — |
+| Java | `.java` | Spring Boot |
+| C# | `.cs` | ASP.NET |
+
+### What Gets Indexed
+
+- **Symbols** — Functions, classes, methods with parameters and return types
+- **Call Graph** — Which functions call which (and who calls them)
+- **Imports/Exports** — Module dependencies
+- **API Routes** — Express, FastAPI, NestJS, Spring Boot endpoints
+- **Entities** — Database models and ORM definitions
+- **Framework Detection** — React components, Angular services, etc.
+
+### Token Savings
+
+CortexCode dramatically reduces the tokens needed to give AI assistants useful context:
+
+```bash
+$ cortexcode stats
+
+╭──────── Token Savings Analysis ────────╮
+│ Source files         154 files          │
+│ Raw project tokens   203,847            │
+│ Full index tokens    45,291             │
+│ Context query tokens 487                │
+│                                         │
+│ Tokens saved         203,360            │
+│ Savings              99.8%              │
+│ Compression ratio    418.6x             │
+╰─────────────────────────────────────────╯
+```
+
+### Interactive HTML Documentation
+
+Generate a full interactive documentation site with:
+
+- **File tree** browser
+- **Symbol list** with filtering
+- **D3.js call graph** visualization (draggable nodes)
+- **Global search** across all symbols
+- **Import/Export** browser
+- **API route** listing
+- **Framework** detection summary
+
+```bash
+cortexcode docs --open
+```
+
+### Incremental Indexing
+
+Only re-index files that changed since last run:
+
+```bash
+cortexcode index -i    # Skip unchanged files
+```
+
+### VS Code Extension
+
+The bundled VS Code extension provides:
+
+- **Hover tooltips** — Hover any symbol to see type, params, callers
+- **Go to definition** — Ctrl+Click using indexed data
+- **Context panel** — View symbol details in a side panel
+- **Status bar** — Shows indexed symbol count
+
+```bash
+cd cortexcode-vscode
+npm install && npm run compile
+# Press F5 to launch in VS Code
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `cortexcode index [path]` | Index a directory |
+| `cortexcode index -i` | Incremental index (changed files only) |
+| `cortexcode context [query]` | Get relevant context for AI |
+| `cortexcode context [query] --tokens` | Show token savings for query |
+| `cortexcode search [query]` | Grep-like symbol search with type/file filters |
+| `cortexcode find [query]` | Semantic search by meaning ("auth handler") |
+| `cortexcode diff` | Show changed symbols since last commit |
+| `cortexcode diff --ref HEAD~3` | Compare against any git ref |
+| `cortexcode stats` | Show project stats and token savings |
+| `cortexcode scan` | Scan dependencies for security warnings |
+| `cortexcode docs --open` | Generate and open interactive docs |
+| `cortexcode dead-code` | Detect potentially unused symbols |
+| `cortexcode complexity` | Analyze code complexity (cyclomatic, nesting, line count) |
+| `cortexcode complexity --min-score 50` | Show only high-complexity functions |
+| `cortexcode impact <symbol>` | Change impact analysis — what breaks if you modify a symbol |
+| `cortexcode dashboard` | Launch live dashboard with auto-refresh on index changes |
+| `cortexcode workspace init` | Initialize a multi-repo workspace |
+| `cortexcode workspace add <path>` | Add a repo to the workspace |
+| `cortexcode workspace list` | List repos in workspace |
+| `cortexcode workspace index` | Index all workspace repos |
+| `cortexcode workspace search <q>` | Search symbols across all repos |
+| `cortexcode watch` | Auto-reindex on file changes |
+| `cortexcode mcp` | Start MCP server for AI agent integration |
+| `cortexcode lsp` | Start Language Server Protocol server |
+
+## How AI Agents Use This
+
+### 1. Context Command (simplest)
+
+```bash
+# Paste this output into your AI chat
+cortexcode context "useAuth" --tokens
+```
+
+### 2. JSON Index (programmatic)
+
+```python
+import json
+
+index = json.load(open('.cortexcode/index.json'))
+
+# Get all functions
+for path, data in index['files'].items():
+    for sym in data['symbols']:
+        print(f"{sym['type']}: {sym['name']} in {path}:{sym['line']}")
+
+# Trace call graph
+for caller, callees in index['call_graph'].items():
+    for callee in callees:
+        print(f"{caller} -> {callee}")
+```
+
+### 3. MCP Server
+
+AI agents can query the index directly via the Model Context Protocol:
+
+```bash
+# Start the MCP server (stdin/stdout)
+cortexcode mcp
+```
+
+**Configuration Examples:**
+
+```json
+// Claude Desktop (claude_desktop_config.json)
+{
+  "mcpServers": {
+    "cortexcode": {
+      "command": "cortexcode",
+      "args": ["mcp"]
+    }
+  }
+}
+
+// Cursor / Windsurf
+{
+  "mcpServers": {
+    "cortexcode": {
+      "command": "cortexcode",
+      "args": ["mcp"]
+    }
+  }
+}
+
+// Open WebUI / AnythingLLM
+{
+  "mcpServers": {
+    "cortexcode": {
+      "command": "cortexcode",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+Available MCP tools:
+- **`cortexcode_search`** — Search symbols by name
+- **`cortexcode_context`** — Get rich context with callers/callees
+- **`cortexcode_file_symbols`** — List all symbols in a file
+- **`cortexcode_call_graph`** — Trace call graph for a symbol
+- **`cortexcode_diff`** — Get changed symbols since last commit
+- **`cortexcode_stats`** — Get project statistics
+- **`cortexcode_deadcode`** — Find potentially unused symbols
+- **`cortexcode_complexity`** — Find most complex functions
+- **`cortexcode_impact`** — Analyze change impact of a symbol
+- **`cortexcode_file_deps`** — Get file dependency graph
+
+### 4. LSP Server
+
+Any LSP-compatible editor can use CortexCode for hover, go-to-definition, and document symbols:
+
+```bash
+cortexcode lsp
+```
+
+### 5. Git Diff Context
+
+See only what changed — perfect for code review:
+
+```bash
+# What symbols changed since last commit?
+cortexcode diff
+
+# Compare against a branch
+cortexcode diff --ref main
+```
+
+### 6. Copilot Chat (`@cortexcode`)
+
+In VS Code with the CortexCode extension, use `@cortexcode` in Copilot Chat:
+
+```
+@cortexcode search handleAuth
+@cortexcode /context authentication
+@cortexcode /impact createUser
+@cortexcode /deadcode
+@cortexcode /complexity
+```
+
+Commands:
+- **`/search`** — Find symbols by name
+- **`/context`** — Get ranked context for a query (relevance + call graph connectivity)
+- **`/impact`** — Change impact analysis (direct/indirect callers, affected files/tests)
+- **`/deadcode`** — List potentially unused symbols
+- **`/complexity`** — Show most complex functions by params + outgoing calls
+
+### 7. Semantic Search
+
+Find symbols by meaning, not just name:
+
+```bash
+cortexcode find "authentication handler"
+cortexcode find "database models"
+cortexcode find "user login flow"
+```
+
+### 8. Code Analysis
+
+```bash
+# Find unused symbols
+cortexcode dead-code
+
+# Show top 10 most complex functions
+cortexcode complexity --top 10
+
+# What breaks if I change createUser?
+cortexcode impact createUser
+```
+
+## Index Format
+
+The index is stored at `.cortexcode/index.json`:
+
+```json
+{
+  "project_root": "/path/to/project",
+  "last_indexed": "2024-03-01T12:00:00",
+  "languages": ["javascript", "typescript", "python"],
+  "files": {
+    "src/auth.ts": {
+      "symbols": [
+        {
+          "name": "AuthService",
+          "type": "class",
+          "line": 10,
+          "params": [],
+          "calls": ["validateToken", "hashPassword"]
+        }
+      ],
+      "imports": [{ "module": "bcrypt", "imported": ["hash", "compare"] }],
+      "exports": [{ "name": "AuthService", "type": "class" }],
+      "api_routes": [{ "method": "POST", "path": "/auth/login" }]
+    }
+  },
+  "call_graph": {
+    "AuthService": ["validateToken", "hashPassword"],
+    "validateToken": ["jwt.verify"]
+  }
+}
+```
+
+## Configuration
+
+CortexCode respects `.gitignore` files (including nested ones) and has built-in ignore patterns for:
+
+- `node_modules/`, `__pycache__/`, `.git/`
+- Build directories (`dist/`, `build/`, `.next/`)
+- IDE files (`.idea/`, `.vscode/`)
+- Package manager files (`vendor/`, `.venv/`)
+
+## Roadmap
+
+- [x] MCP server for direct AI agent integration
+- [x] Tiktoken-based accurate token counting
+- [x] Semantic search over symbols (TF-IDF + synonym expansion)
+- [x] Cross-file type inference
+- [x] Git diff-aware context (show only changed symbols)
+- [x] Language server protocol (LSP) support
+- [x] Dependency vulnerability scanning
+- [x] CI/CD integration (GitHub Action)
+- [x] Multi-repo workspace support
+- [x] Custom plugin system for framework-specific extractors
+- [x] Web dashboard for index visualization
+- [x] Flutter/Dart language support (regex-based)
+- [x] React Native / Expo framework detection
+- [x] Native Android (Kotlin/Java) framework detection
+- [x] Native iOS (Swift/SwiftUI/UIKit) framework detection
+- [x] Django / Flask framework detection
+- [ ] VS Code Marketplace publishing
+- [ ] OpenAI embedding-based semantic search
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+```bash
+# Development install
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Lint
+ruff check cortexcode/
+```
+
+## License
+
+MIT — See [LICENSE](LICENSE)

cortexcode-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+cortexcode/__init__.py,sha256=6dAo1HGYcfh35uqvPmnci9spfrTgF-OK1vvZ16iwN1I,87
+cortexcode/analysis.py,sha256=25c8UBLNhYqWn2qOVp1wU05be9Pt_AZmp27XMDM3ysU,11503
+cortexcode/cli.py,sha256=uG2e-hIv75q7CbbvaCwXros2qVj5wRYVrnVysmIwjYc,30751
+cortexcode/context.py,sha256=8L4VlXamEYl9rImeGOxW9DhoYBhMuZQi5-mhhSSjOAw,9765
+cortexcode/dashboard.py,sha256=NNK4EhgBo3gBuwwntT5wIi7ZlX1ThHVlbxn6q0c-HdE,5361
+cortexcode/docs.py,sha256=OGrHnWE3qh_rgILMALxt2m2RLa3KE8WfYhFALPF1Nn0,65410
+cortexcode/git_diff.py,sha256=YEEZM2yKYztE-T7rI5iBf2NluY4G1WIjlp-DprZ-6Rs,5742
+cortexcode/indexer.py,sha256=R178y_PKgLjmasyE3ftQjDRA3AxaeI_qyd93pJZLHZQ,81924
+cortexcode/lsp_server.py,sha256=mAPk78OVWQodBjBI3WhqEjrwjXrb0MF630IYDZ8_MLM,11102
+cortexcode/mcp_server.py,sha256=h18bZQ6_6zZVmQfTnQYiP4XGZmzfKBVZZfJQra12cy4,18866
+cortexcode/plugins.py,sha256=6WsmnvRT7D_coxD6YgwB-Dpu_iKOS89FNnT-gkgK4-8,6298
+cortexcode/semantic_search.py,sha256=PO1FjbQhKf6EGfwtwHcdqVXL5W_xMr4e7GxuctdrFzM,8745
+cortexcode/vuln_scan.py,sha256=edU6viXXPLxHdlwDons05g9tLrGuLdPvrNDY-QcqPlU,8539
+cortexcode/watcher.py,sha256=PdY54UzzA70Ff3og2Vv6jE-hzppJRZKpxE4tK8iDVNo,3672
+cortexcode/workspace.py,sha256=ewm5UW_9NQJ0EgjPm46zHMIpZft5UMAlBuX7tt8LWbA,6463
+cortexcode-0.1.0.dist-info/licenses/LICENSE,sha256=DWE8vkHgP2ChQTJHFWtrutLbuHQUBsU_InyfesP4neo,1067
+cortexcode-0.1.0.dist-info/METADATA,sha256=5-ym5wsy3CBFKULNsY3teKAF-5TBM9w7h2qkQqofokw,14707
+cortexcode-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+cortexcode-0.1.0.dist-info/entry_points.txt,sha256=ZqCHJQMwlffLmdD1m6nyemXlk0M4GWntSH2QORXfNJo,51
+cortexcode-0.1.0.dist-info/top_level.txt,sha256=r8FxzjLfKhRXXcORnECtGo7i2zKYXlV7v1XnIJ0SOc0,11
+cortexcode-0.1.0.dist-info/RECORD,,

cortexcode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cortexcode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cortexcode = cortexcode.cli:main

cortexcode-0.1.0.dist-info/licenses/LICENSE

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

cortexcode-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cortexcode