msl 0.1.0__tar.gz

msl-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Murad
+
+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.

msl-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include src/msl/skills *.md
+include LICENSE
+include README.md

msl-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: msl
+Version: 0.1.0
+Summary: MSL — Muradian Skill Languages: Generate platform-specific skill files for AI coding assistants
+Author: Murad
+License: MIT
+Project-URL: Homepage, https://github.com/mozaddedalfeshani/msl
+Project-URL: Repository, https://github.com/mozaddedalfeshani/msl
+Project-URL: Issues, https://github.com/mozaddedalfeshani/msl/issues
+Keywords: ai,coding-assistant,cursor,vscode,claude,codex,skill,rules,developer-tools,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0
+Requires-Dist: questionary>=2.0
+Dynamic: license-file
+
+# MSL — Muradian Skill Languages
+
+Generate platform-specific skill/rule files for AI coding assistants with one command. No need to remember which file goes where — `msl` handles the structure for you.
+
+## Install
+
+```bash
+pip install msl
+```
+
+## Usage
+
+```bash
+msl
+```
+
+The wizard will:
+
+1. **Detect** your environment (Node.js, Cursor, VS Code, Claude Code, Codex)
+2. **Scan** your project to auto-detect frameworks, languages, package manager
+3. **Ask** which platform to target
+4. **Ask** your project path (current directory or custom)
+5. **Ask** your project type (auto-suggested from scan)
+6. **Ask** your preference level (Simple → Industry Standard)
+7. **Generate** the correct file in the right location with project-aware content
+
+```
+╭──────────────────────────────────────╮
+│  MSL — Muradian Skill Languages     │
+╰──────────────────────────────────────╯
+
+  Environment Check
+  ✓ Node.js  v20.11.0
+  ✓ Cursor   0.45.0
+  ✓ VS Code  1.89.1
+  ✓ Claude   2.1.0
+  ✓ Codex    0.72.0
+
+  Project Scan
+  Name:       my-saas-app
+  Languages:  TypeScript
+  Detected:   Next.js, App Router, tailwindcss, prisma
+  Type:       Web (Next.js) (95% confidence)
+```
+
+## Supported Platforms
+
+| Platform    | Output Path                       |
+| ----------- | --------------------------------- |
+| Cursor      | `.cursor/rules.md`                |
+| VS Code     | `.github/copilot-instructions.md` |
+| Claude Code | `CLAUDE.md`                       |
+| Codex       | `AGENTS.md`                       |
+
+## Supported Project Types
+
+- **Flutter** — Dart, widgets, state management, routing
+- **Web (Next.js)** — App Router, Server Components, data fetching
+- **Web (React/Vite)** — SPA, hooks, React Router, Zustand
+- **Rust (Server)** — Axum/Actix, async, sqlx, error handling
+- **Node.js (Server)** — Express/Fastify, TypeScript, Prisma
+- **Python** — FastAPI/Flask, typed Python, pytest
+- **Go (Server)** — Chi/Gin, structured logging, sqlx
+
+## Preference Levels
+
+| Level             | What it includes                                  |
+| ----------------- | ------------------------------------------------- |
+| Simple            | Clean code basics, modular structure              |
+| Intermediate      | Patterns, testing, conventions, data layer        |
+| Industry Standard | Full architecture, CI/CD, security, observability |
+
+## Smart Features
+
+- **Auto-detection**: Scans `package.json`, `Cargo.toml`, `pubspec.yaml`, `pyproject.toml`, `go.mod` to identify your stack
+- **Context injection**: Appends detected project name, frameworks, and package manager to the generated file
+- **Correct conventions**: Uses each platform's real config file path — not a generic filename
+- **Safe writes**: Always asks before overwriting existing files
+
+## CLI Options
+
+```bash
+msl              # Run the interactive wizard
+msl --version    # Show version
+msl --help       # Show help
+```
+
+## Development
+
+```bash
+git clone https://github.com/murad/msl.git
+cd msl
+pip install -e .
+msl
+```
+
+## License
+
+MIT

msl-0.1.0/README.md

@@ -0,0 +1,99 @@
+# MSL — Muradian Skill Languages
+
+Generate platform-specific skill/rule files for AI coding assistants with one command. No need to remember which file goes where — `msl` handles the structure for you.
+
+## Install
+
+```bash
+pip install msl
+```
+
+## Usage
+
+```bash
+msl
+```
+
+The wizard will:
+
+1. **Detect** your environment (Node.js, Cursor, VS Code, Claude Code, Codex)
+2. **Scan** your project to auto-detect frameworks, languages, package manager
+3. **Ask** which platform to target
+4. **Ask** your project path (current directory or custom)
+5. **Ask** your project type (auto-suggested from scan)
+6. **Ask** your preference level (Simple → Industry Standard)
+7. **Generate** the correct file in the right location with project-aware content
+
+```
+╭──────────────────────────────────────╮
+│  MSL — Muradian Skill Languages     │
+╰──────────────────────────────────────╯
+
+  Environment Check
+  ✓ Node.js  v20.11.0
+  ✓ Cursor   0.45.0
+  ✓ VS Code  1.89.1
+  ✓ Claude   2.1.0
+  ✓ Codex    0.72.0
+
+  Project Scan
+  Name:       my-saas-app
+  Languages:  TypeScript
+  Detected:   Next.js, App Router, tailwindcss, prisma
+  Type:       Web (Next.js) (95% confidence)
+```
+
+## Supported Platforms
+
+| Platform    | Output Path                       |
+| ----------- | --------------------------------- |
+| Cursor      | `.cursor/rules.md`                |
+| VS Code     | `.github/copilot-instructions.md` |
+| Claude Code | `CLAUDE.md`                       |
+| Codex       | `AGENTS.md`                       |
+
+## Supported Project Types
+
+- **Flutter** — Dart, widgets, state management, routing
+- **Web (Next.js)** — App Router, Server Components, data fetching
+- **Web (React/Vite)** — SPA, hooks, React Router, Zustand
+- **Rust (Server)** — Axum/Actix, async, sqlx, error handling
+- **Node.js (Server)** — Express/Fastify, TypeScript, Prisma
+- **Python** — FastAPI/Flask, typed Python, pytest
+- **Go (Server)** — Chi/Gin, structured logging, sqlx
+
+## Preference Levels
+
+| Level             | What it includes                                  |
+| ----------------- | ------------------------------------------------- |
+| Simple            | Clean code basics, modular structure              |
+| Intermediate      | Patterns, testing, conventions, data layer        |
+| Industry Standard | Full architecture, CI/CD, security, observability |
+
+## Smart Features
+
+- **Auto-detection**: Scans `package.json`, `Cargo.toml`, `pubspec.yaml`, `pyproject.toml`, `go.mod` to identify your stack
+- **Context injection**: Appends detected project name, frameworks, and package manager to the generated file
+- **Correct conventions**: Uses each platform's real config file path — not a generic filename
+- **Safe writes**: Always asks before overwriting existing files
+
+## CLI Options
+
+```bash
+msl              # Run the interactive wizard
+msl --version    # Show version
+msl --help       # Show help
+```
+
+## Development
+
+```bash
+git clone https://github.com/murad/msl.git
+cd msl
+pip install -e .
+msl
+```
+
+## License
+
+MIT

msl-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "msl"
+version = "0.1.0"
+description = "MSL — Muradian Skill Languages: Generate platform-specific skill files for AI coding assistants"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "Murad"},
+]
+keywords = [
+    "ai", "coding-assistant", "cursor", "vscode", "claude", "codex",
+    "skill", "rules", "developer-tools", "cli",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Code Generators",
+    "Typing :: Typed",
+]
+dependencies = [
+    "rich>=13.0",
+    "questionary>=2.0",
+]
+
+[project.scripts]
+msl = "msl.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/mozaddedalfeshani/msl"
+Repository = "https://github.com/mozaddedalfeshani/msl"
+Issues = "https://github.com/mozaddedalfeshani/msl/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+msl = ["skills/**/*.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

msl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

msl-0.1.0/src/msl/__init__.py

@@ -0,0 +1,3 @@
+"""MSL — Muradian Skill Languages CLI."""
+
+__version__ = "0.1.0"

msl-0.1.0/src/msl/cli.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import sys
+
+
+def main() -> None:
+    # Handle --version / --help before importing heavy dependencies
+    if len(sys.argv) > 1:
+        arg = sys.argv[1]
+        if arg in ("--version", "-V"):
+            from . import __version__
+            print(f"msl {__version__}")
+            return
+        if arg in ("--help", "-h"):
+            print(
+                "Usage: msl [options]\n"
+                "\n"
+                "  Interactive wizard that generates platform-specific skill\n"
+                "  files for AI coding assistants (Cursor, VS Code, Claude Code, Codex).\n"
+                "\n"
+                "Options:\n"
+                "  -h, --help     Show this help message\n"
+                "  -V, --version  Show version number\n"
+            )
+            return
+
+    from .ui import console, run_wizard, show_cancelled, show_success
+    from .writer import generate_skill_file
+
+    try:
+        result = run_wizard()
+        if result is None:
+            sys.exit(0)
+
+        ctx, scan = result
+        output_path = generate_skill_file(ctx, scan)
+        show_success(output_path)
+
+    except KeyboardInterrupt:
+        show_cancelled()
+        sys.exit(0)
+    except FileExistsError as exc:
+        console.print(f"\n[yellow]{exc}[/yellow]")
+        sys.exit(0)
+    except Exception as exc:
+        console.print(f"\n[red]Error: {exc}[/red]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

msl-0.1.0/src/msl/detection.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import platform as platform_mod
+import shutil
+import subprocess
+from pathlib import Path
+
+from .models import DetectedTool
+
+
+def _run_version_cmd(cmd: str) -> str | None:
+    try:
+        result = subprocess.run(
+            [cmd, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return (result.stdout.strip() or result.stderr.strip()) or None
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        pass
+    return None
+
+
+def _check_macos_app(app_name: str) -> bool:
+    return Path(f"/Applications/{app_name}.app").exists()
+
+
+def detect_nodejs() -> DetectedTool:
+    version = _run_version_cmd("node")
+    return DetectedTool(
+        name="Node.js",
+        installed=version is not None,
+        version=version,
+        path=shutil.which("node"),
+    )
+
+
+def detect_cursor() -> DetectedTool:
+    cursor_path = shutil.which("cursor")
+    if cursor_path:
+        version = _run_version_cmd("cursor")
+        return DetectedTool(
+            name="Cursor", installed=True, version=version, path=cursor_path
+        )
+    if platform_mod.system() == "Darwin" and _check_macos_app("Cursor"):
+        return DetectedTool(
+            name="Cursor", installed=True, path="/Applications/Cursor.app"
+        )
+    return DetectedTool(name="Cursor", installed=False)
+
+
+def detect_vscode() -> DetectedTool:
+    code_path = shutil.which("code")
+    if code_path:
+        version = _run_version_cmd("code")
+        return DetectedTool(
+            name="VS Code", installed=True, version=version, path=code_path
+        )
+    if platform_mod.system() == "Darwin" and _check_macos_app("Visual Studio Code"):
+        return DetectedTool(
+            name="VS Code",
+            installed=True,
+            path="/Applications/Visual Studio Code.app",
+        )
+    return DetectedTool(name="VS Code", installed=False)
+
+
+def detect_claude_code() -> DetectedTool:
+    claude_path = shutil.which("claude")
+    if claude_path:
+        version = _run_version_cmd("claude")
+        return DetectedTool(
+            name="Claude Code", installed=True, version=version, path=claude_path
+        )
+    return DetectedTool(name="Claude Code", installed=False)
+
+
+def detect_codex() -> DetectedTool:
+    codex_path = shutil.which("codex")
+    if codex_path:
+        version = _run_version_cmd("codex")
+        return DetectedTool(
+            name="Codex", installed=True, version=version, path=codex_path
+        )
+    return DetectedTool(name="Codex", installed=False)
+
+
+def detect_all() -> dict[str, DetectedTool]:
+    return {
+        "nodejs": detect_nodejs(),
+        "cursor": detect_cursor(),
+        "vscode": detect_vscode(),
+        "claude-code": detect_claude_code(),
+        "codex": detect_codex(),
+    }

msl-0.1.0/src/msl/models.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+
+class Platform(Enum):
+    CURSOR = "cursor"
+    VSCODE = "vscode"
+    CLAUDE_CODE = "claude-code"
+    CODEX = "codex"
+
+    @property
+    def display_name(self) -> str:
+        return {
+            Platform.CURSOR: "Cursor",
+            Platform.VSCODE: "VS Code",
+            Platform.CLAUDE_CODE: "Claude Code",
+            Platform.CODEX: "Codex",
+        }[self]
+
+
+class ProjectType(Enum):
+    FLUTTER = "flutter"
+    NEXTJS = "nextjs"
+    REACT_VITE = "react-vite"
+    RUST_SERVER = "rust-server"
+    NODEJS_SERVER = "nodejs-server"
+    PYTHON = "python"
+    GO_SERVER = "go-server"
+
+    @property
+    def display_name(self) -> str:
+        return {
+            ProjectType.FLUTTER: "Flutter",
+            ProjectType.NEXTJS: "Web (Next.js)",
+            ProjectType.REACT_VITE: "Web (React/Vite)",
+            ProjectType.RUST_SERVER: "Rust (Server)",
+            ProjectType.NODEJS_SERVER: "Node.js (Server)",
+            ProjectType.PYTHON: "Python",
+            ProjectType.GO_SERVER: "Go (Server)",
+        }[self]
+
+
+class PreferenceTier(Enum):
+    SIMPLE = "simple"
+    INTERMEDIATE = "intermediate"
+    INDUSTRY_STANDARD = "industry_standard"
+
+    @property
+    def display_name(self) -> str:
+        return {
+            PreferenceTier.SIMPLE: "Simple — modular, clean code basics",
+            PreferenceTier.INTERMEDIATE: "Intermediate — patterns, testing, conventions",
+            PreferenceTier.INDUSTRY_STANDARD: "Industry Standard — full architecture & delivery rules",
+        }[self]
+
+
+@dataclass
+class DetectedTool:
+    name: str
+    installed: bool
+    version: str | None = None
+    path: str | None = None
+
+
+@dataclass
+class SkillGenContext:
+    target_platform: Platform
+    project_path: Path
+    project_type: ProjectType
+    preference_tier: PreferenceTier
+    detected_tools: dict[str, DetectedTool] = field(default_factory=dict)
+
+    @property
+    def output_path(self) -> Path:
+        from .path_rules import get_output_path
+
+        return get_output_path(self.target_platform, self.project_path)

msl-0.1.0/src/msl/path_rules.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .models import Platform
+
+# Platform → (hidden directory name | None, filename)
+# Based on each tool's ACTUAL config-file convention.
+PLATFORM_PATHS: dict[str, tuple[str | None, str]] = {
+    Platform.CURSOR.value: (".cursor", "rules.md"),          # .cursor/rules.md
+    Platform.VSCODE.value: (".github", "copilot-instructions.md"),  # .github/copilot-instructions.md
+    Platform.CLAUDE_CODE.value: (None, "CLAUDE.md"),         # CLAUDE.md at project root
+    Platform.CODEX.value: (None, "AGENTS.md"),               # AGENTS.md at project root
+}
+
+
+def get_output_path(platform: Platform, project_root: Path) -> Path:
+    directory, filename = PLATFORM_PATHS[platform.value]
+    if directory:
+        return project_root / directory / filename
+    return project_root / filename
+
+
+def get_output_dir(platform: Platform, project_root: Path) -> Path:
+    directory, _ = PLATFORM_PATHS[platform.value]
+    if directory:
+        return project_root / directory
+    return project_root