deleetify 0.1.0__py3-none-any.whl

deleetify/__main__.py

@@ -0,0 +1,8 @@
+from deleetify.main import main as app
+import asyncio
+
+def main():
+    asyncio.run(app())
+
+if __name__ == "__main__":
+    main()

deleetify/acp_client/client.py

@@ -0,0 +1,161 @@
+from typing import Any, override
+
+from acp import (
+    Agent,
+    Client,
+    RequestError,
+)
+from acp.schema import (
+    AgentMessageChunk,
+    AgentPlanUpdate,
+    AgentThoughtChunk,
+    AudioContentBlock,
+    AvailableCommandsUpdate,
+    ConfigOptionUpdate,
+    CreateTerminalResponse,
+    CurrentModeUpdate,
+    EmbeddedResourceContentBlock,
+    EnvVariable,
+    ImageContentBlock,
+    KillTerminalResponse,
+    PermissionOption,
+    ReadTextFileResponse,
+    ReleaseTerminalResponse,
+    RequestPermissionResponse,
+    ResourceContentBlock,
+    SessionInfoUpdate,
+    TerminalOutputResponse,
+    TextContentBlock,
+    ToolCallProgress,
+    ToolCallStart,
+    ToolCallUpdate,
+    UsageUpdate,
+    UserMessageChunk,
+    WaitForTerminalExitResponse,
+    WriteTextFileResponse,
+)
+
+
+class DeleetifyClient(Client):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.response: str = ""
+
+    @override
+    async def request_permission(
+        self,
+        options: list[PermissionOption],
+        session_id: str,
+        tool_call: ToolCallUpdate,
+        **kwargs: Any,
+    ) -> RequestPermissionResponse:
+        raise RequestError.method_not_found("session/request_permission")
+
+    @override
+    async def write_text_file(
+        self, content: str, path: str, session_id: str, **kwargs: Any
+    ) -> WriteTextFileResponse | None:
+        raise RequestError.method_not_found("fs/write_text_file")
+
+    @override
+    async def read_text_file(
+        self,
+        path: str,
+        session_id: str,
+        limit: int | None = None,
+        line: int | None = None,
+        **kwargs: Any,
+    ) -> ReadTextFileResponse:
+        raise RequestError.method_not_found("fs/read_text_file")
+
+    @override
+    async def create_terminal(
+        self,
+        command: str,
+        session_id: str,
+        args: list[str] | None = None,
+        cwd: str | None = None,
+        env: list[EnvVariable] | None = None,
+        output_byte_limit: int | None = None,
+        **kwargs: Any,
+    ) -> CreateTerminalResponse:
+        raise RequestError.method_not_found("terminal/create")
+
+    @override
+    async def terminal_output(
+        self, session_id: str, terminal_id: str, **kwargs: Any
+    ) -> TerminalOutputResponse:
+        raise RequestError.method_not_found("terminal/output")
+
+    @override
+    async def release_terminal(
+        self, session_id: str, terminal_id: str, **kwargs: Any
+    ) -> ReleaseTerminalResponse | None:
+        raise RequestError.method_not_found("terminal/release")
+
+    @override
+    async def wait_for_terminal_exit(
+        self, session_id: str, terminal_id: str, **kwargs: Any
+    ) -> WaitForTerminalExitResponse:
+        raise RequestError.method_not_found("terminal/wait_for_exit")
+
+    @override
+    async def kill_terminal(
+        self, session_id: str, terminal_id: str, **kwargs: Any
+    ) -> KillTerminalResponse | None:
+        raise RequestError.method_not_found("terminal/kill")
+
+    @override
+    async def session_update(
+        self,
+        session_id: str,
+        update: (
+            UserMessageChunk
+            | AgentMessageChunk
+            | AgentThoughtChunk
+            | ToolCallStart
+            | ToolCallProgress
+            | AgentPlanUpdate
+            | AvailableCommandsUpdate
+            | CurrentModeUpdate
+            | ConfigOptionUpdate
+            | SessionInfoUpdate
+            | UsageUpdate
+        ),
+        **kwargs: Any,
+    ) -> None:
+        if not isinstance(update, AgentMessageChunk):
+            return
+
+        content = update.content
+        text: str = ""
+
+        if isinstance(content, TextContentBlock):
+            text = content.text
+        elif isinstance(content, ImageContentBlock):
+            text = "<image>"
+        elif isinstance(content, AudioContentBlock):
+            text = "<audio>"
+        elif isinstance(content, ResourceContentBlock):
+            text = content.uri or "<resource>"
+        elif isinstance(content, EmbeddedResourceContentBlock):
+            text = "<resource>"
+        else:
+            text = "<content>"
+
+        self.response += text
+
+    @override
+    async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        raise RequestError.method_not_found(method)
+
+    @override
+    async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
+        raise RequestError.method_not_found(method)
+
+    @override
+    def on_connect(self, conn: Agent) -> None: ...
+
+

deleetify/acp_client/client_handler.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+import asyncio.subprocess as aio_subprocess
+import os
+from uuid import uuid4
+
+from acp import (
+    PROTOCOL_VERSION,
+    NewSessionResponse,
+    connect_to_agent,
+    text_block,
+)
+from acp.core import ClientSideConnection
+from acp.schema import (
+    ClientCapabilities,
+    Implementation,
+)
+
+import asyncio
+import asyncio.subprocess as aio_subprocess
+from deleetify.acp_client.client import DeleetifyClient
+from deleetify.acp_client.exceptions import AgentProcessError
+from deleetify.processor.config.model import Config
+import asyncio.subprocess as aio_subprocess
+
+async def create_agent_process(config: Config) -> aio_subprocess.Process:
+    program = config.command
+    spawn_program = program
+    spawn_args = config.args
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            spawn_program,
+            *spawn_args,
+            env=config.envs,
+            stdin=aio_subprocess.PIPE,
+            stdout=aio_subprocess.PIPE,
+        )
+    except FileNotFoundError:
+        raise AgentProcessError(
+            f"No agent {config.command} fount in system"
+        )
+
+    if proc.stdin is None or proc.stdout is None:
+        raise AgentProcessError(
+            f"Agent {config.command} process does not expose stdio pipes"
+        )
+
+    return proc
+
+class AcpHandler:
+    def __init__(
+            self, 
+            client: DeleetifyClient, 
+            proc: aio_subprocess.Process, 
+            conn: ClientSideConnection
+        ) -> None:
+            """Keep __init__ synchronous. Only assign pre-resolved variables here."""
+            self.client: DeleetifyClient = client
+            self.proc: aio_subprocess.Process = proc
+            self.conn: ClientSideConnection = conn
+
+    @classmethod
+    async def create(
+        cls, client: DeleetifyClient, proc: aio_subprocess.Process
+    ) -> AcpHandler:
+        conn: ClientSideConnection = connect_to_agent(
+            client, proc.stdin, proc.stdout
+        )
+        _ = await conn.initialize(
+            protocol_version=PROTOCOL_VERSION,
+            client_capabilities=ClientCapabilities(),
+            client_info=Implementation(
+                name="deleetify", title="Deleetify Client", version="0.1.0"
+            ),
+        )
+        
+        return cls(client, proc, conn)
+
+    async def createSession(self) -> NewSessionResponse:
+        session = await self.conn.new_session(mcp_servers=[], cwd=os.getcwd())
+        return session
+
+    async def prompt(self, session_id: str, prompt: str) -> str:
+        response = await self.conn.prompt(
+            session_id=session_id,
+            prompt=[text_block(prompt)],
+            message_id=str(uuid4()),
+        )
+
+        return self.client.response

deleetify/acp_client/exceptions.py

@@ -0,0 +1,5 @@
+
+class AgentProcessError(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+

deleetify/cli/exceptions.py

@@ -0,0 +1,9 @@
+
+class ConfigNotFound(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class NotATomlFile(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

deleetify/cli/lang_model.py

@@ -0,0 +1,10 @@
+from enum import StrEnum, auto
+
+class Lang(StrEnum):
+    PYTHON3 = auto()
+    JAVASCRIPT = auto()
+
+    def externsion(self) -> str:
+        match self:
+            case Lang.PYTHON3: return 'py'
+            case Lang.JAVASCRIPT: return 'js'

deleetify/cli/model.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+import clap
+from clap import arg
+
+from deleetify.cli.lang_model import Lang
+
+
+@clap.command()
+class Cli(clap.Parser):
+    """
+    Makes local leetcode setup less painfull
+    """
+
+    name: str
+    """Name of the leetcode problem [Example: `208. Implement Trie (Prefix Tree)`]"""
+
+    lang: Lang = arg(short=True, long=True, default_value=Lang.PYTHON3)
+
+    config: Path = arg(short=True, long=True, default_value=Path("deleetify.toml"))

deleetify/cli/parser.py

@@ -0,0 +1,14 @@
+from .exceptions import ConfigNotFound, NotATomlFile
+from .model import Cli
+
+def parse_cli_values() -> Cli:
+    parsed = Cli.parse()
+    config = parsed.config
+
+    if not config.is_file():
+        raise ConfigNotFound(f"{config.name} not exist")
+
+    if not config.name.endswith('.toml'):
+        raise NotATomlFile(f"It is not a toml file: {config.name}")
+
+    return parsed

deleetify/file_name/exceptions.py

@@ -0,0 +1,4 @@
+
+class InvalidUserInput(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

deleetify/file_name/parser.py

@@ -0,0 +1,27 @@
+from typing import Self
+import re
+
+from deleetify.file_name.exceptions import InvalidUserInput
+
+
+
+class FileNameProcessor:
+    file_name: str
+
+    def __init__(self, file_name: str) -> None:
+        self.file_name = file_name
+
+    def convert_to_kebab_case(self) -> Self:
+        s = re.sub(r'(?<!^)(?=[A-Z])', ' ', self.file_name)
+        s = s.lower()
+        s = re.sub(r'[^a-z0-9]+', '-', s)
+        self.file_name = s.strip('-')
+        return self
+
+    def split_number_and_name(self) -> tuple[str, str]:
+        matches = re.match(r'^(\d+)-([a-z0-9-]+)', self.file_name)
+        if matches is None:
+            raise InvalidUserInput(f"Leetcode name is not valid")
+        code = matches.group(1)
+        name = matches.group(2)
+        return (code, name)

deleetify/main.py

@@ -0,0 +1,63 @@
+import asyncio
+from collections.abc import Coroutine
+import logging
+import sys
+from typing import Any, Callable
+
+from deleetify.acp_client.client import DeleetifyClient
+from deleetify.acp_client.client_handler import AcpHandler, create_agent_process
+from .cli.parser import parse_cli_values
+from deleetify.file_name.parser import FileNameProcessor
+from deleetify.processor.config.parser import process_config_toml
+from deleetify.processor.leetcode.parser import parse_leetcode
+from deleetify.processor.leetcode.request import get_leetcode_response
+from deleetify.prompt.agent_prompt import get_prompt
+
+logger = logging.getLogger(__name__)
+
+
+def exception_then_log_exit[T](
+    callback: Callable[..., Coroutine[Any, Any, T]],
+) -> Callable[..., Coroutine[Any, Any, T]]:
+
+    async def wrapper(*args, **kwargs) -> T:
+        try:
+            return await callback(*args, **kwargs)
+        except Exception as e:
+            logging.error(e)
+            sys.exit(1)
+
+    return wrapper
+
+
+@exception_then_log_exit
+async def main():
+    cli = parse_cli_values()
+    config = process_config_toml(cli.config)
+
+    code, leetcode_name = (
+        FileNameProcessor(cli.name).convert_to_kebab_case().split_number_and_name()
+    )
+
+    leetcode_response = get_leetcode_response(leetcode_name)
+    leetcode_response = parse_leetcode(leetcode_response, cli.lang)
+
+    proc = await create_agent_process(config)
+    client_impl = DeleetifyClient()
+
+    client_handler = await AcpHandler.create(client_impl, proc)
+
+    session = await client_handler.createSession()
+
+    # Let the agent create file if needed
+    file_name = f"{code}-{leetcode_name}.{cli.lang.externsion()}"
+
+    prompt = get_prompt(file_name, leetcode_response)
+    agent_response = await client_handler.prompt(session.session_id, prompt)
+    print(f"{agent_response}")
+
+    proc.terminate()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

deleetify/processor/config/exceptions.py

@@ -0,0 +1,4 @@
+
+class ConfigParseError(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

deleetify/processor/config/model.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Config:
+    command: str
+    args: list[str]
+    envs: dict[str, str]

deleetify/processor/config/parser.py

@@ -0,0 +1,107 @@
+from pathlib import Path
+import tomllib
+from typing import Any
+
+from deleetify.processor.config.exceptions import ConfigParseError
+from deleetify.processor.config.model import Config
+
+
+def read_toml(file: Path) -> dict[str, Any]:
+    with open(file.name, "rb") as f:
+        return tomllib.load(f)
+
+
+def select_provider_name(
+    providers: dict[str, Any], content: dict[str, Any], path: Path
+) -> str:
+    provider_keys = providers.keys()
+    if len(provider_keys) > 1:
+        if "default" not in content.keys():
+            raise ConfigParseError(f"multiple provider found specify `default` key")
+
+        default_key = content["default"]
+        if not isinstance(default_key, dict):
+            raise ConfigParseError(
+                f"default key must contain key-value pair in toml: {path.name}"
+            )
+
+        if "provider" not in default_key:
+            raise ConfigParseError(f"No provider key in default")
+        default_provider = default_key["provider"]
+
+        if not isinstance(default_provider, str):
+            raise ConfigParseError(
+                f"provider inside default must contain string but {default_provider}"
+            )
+
+        if default_provider not in providers:
+            raise ConfigParseError(f"default provider must be configured")
+
+        return default_provider
+
+    if len(provider_keys) == 0:
+        raise ConfigParseError(f"No providers defined")
+
+    selected_provider_name = ""
+    for provider_name in provider_keys:
+        selected_provider_name = provider_name
+
+    return selected_provider_name
+
+
+def parse_provider(provider_name: str, providers: dict[str, Any]) -> Config:
+    provider = providers[provider_name]
+    if not isinstance(provider, dict):
+        raise ConfigParseError(f"Provider {provider_name} config is not valid")
+
+    provider_keys = provider.keys()
+    if "command" not in provider_keys:
+        raise ConfigParseError(f"command key in {provider_name} is missing")
+
+    if not isinstance(provider["command"], str):
+        raise ConfigParseError(f"command key is not valid in provider {provider_name}")
+
+    args: list[str] = []
+    if "args" in provider_keys:
+        if not isinstance(provider["args"], list):
+            raise ConfigParseError(f"args key is not valid in provider {provider_name}")
+        for value in provider["args"]:
+            if not isinstance(value, str):
+                raise ConfigParseError(f"args item `{value}` is not valid in provider {provider_name}")
+
+        args = provider["args"]
+
+    envs: dict[str, str] = {}
+    if "envs" in provider_keys:
+        if not isinstance(provider["envs"], dict):
+            raise ConfigParseError(f"envs key is not valid in provider {provider_name}")
+        for key, value in provider["envs"].items():
+            if not isinstance(key, str):
+                raise ConfigParseError(
+                    f"envs key `{key}` is not valid in provider {provider_name}"
+                )
+            if not isinstance(value, str):
+                raise ConfigParseError(
+                    f"envs value `{value}` for `{key}` is not valid in provider {provider_name}"
+                )
+            envs[key] = value
+
+    config = Config(provider["command"], args, envs)
+    return config
+
+
+def process_config_toml(path: Path) -> Config:
+    content = read_toml(path)
+
+    if "provider" not in content.keys():
+        raise ConfigParseError(f"provider key not found in toml: {path.name}")
+
+    providers = content["provider"]
+    if not isinstance(providers, dict):
+        raise ConfigParseError(
+            f"provider key must contain key-value pair in toml: {path.name}"
+        )
+
+    provider_name = select_provider_name(providers, content, path)
+    config = parse_provider(provider_name, providers)
+    return config

deleetify/processor/leetcode/exceptions.py

@@ -0,0 +1,9 @@
+
+class LeetCodeRequestError(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class LeetCodeRequestParseError(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

deleetify/processor/leetcode/model.py

@@ -0,0 +1,70 @@
+from typing import Any
+from pydantic import BaseModel, Field
+
+
+class TopicTag(BaseModel):
+    name: str
+    slug: str
+    translated_name: Any = Field(..., alias='translatedName')
+
+
+class CodeSnippet(BaseModel):
+    lang: str
+    lang_slug: str = Field(..., alias='langSlug')
+    code: str
+
+
+class Solution(BaseModel):
+    id: str
+    can_see_detail: bool = Field(..., alias='canSeeDetail')
+    paid_only: bool = Field(..., alias='paidOnly')
+    has_video_solution: bool = Field(..., alias='hasVideoSolution')
+    paid_only_video: bool = Field(..., alias='paidOnlyVideo')
+
+
+class Question(BaseModel):
+    question_id: str = Field(..., alias='questionId')
+    question_frontend_id: str = Field(..., alias='questionFrontendId')
+    bound_topic_id: Any = Field(..., alias='boundTopicId')
+    title: str
+    title_slug: str = Field(..., alias='titleSlug')
+    content: str
+    translated_title: Any = Field(..., alias='translatedTitle')
+    translated_content: Any = Field(..., alias='translatedContent')
+    is_paid_only: bool = Field(..., alias='isPaidOnly')
+    difficulty: str
+    likes: int
+    dislikes: int
+    is_liked: Any = Field(..., alias='isLiked')
+    similar_questions: str = Field(..., alias='similarQuestions')
+    example_testcases: str = Field(..., alias='exampleTestcases')
+    contributors: list[Any]
+    topic_tags: list[TopicTag] = Field(..., alias='topicTags')
+    company_tag_stats: Any = Field(..., alias='companyTagStats')
+    code_snippets: list[CodeSnippet] = Field(..., alias='codeSnippets')
+    stats: str
+    hints: list[str]
+    solution: Solution
+    status: Any
+    sample_test_case: str = Field(..., alias='sampleTestCase')
+    meta_data: str = Field(..., alias='metaData')
+    judger_available: bool = Field(..., alias='judgerAvailable')
+    judge_type: str = Field(..., alias='judgeType')
+    mysql_schemas: list[Any] = Field(..., alias='mysqlSchemas')
+    enable_run_code: bool = Field(..., alias='enableRunCode')
+    enable_test_mode: bool = Field(..., alias='enableTestMode')
+    enable_debugger: bool = Field(..., alias='enableDebugger')
+    env_info: str = Field(..., alias='envInfo')
+    library_url: Any = Field(..., alias='libraryUrl')
+    admin_url: Any = Field(..., alias='adminUrl')
+    challenge_question: Any = Field(..., alias='challengeQuestion')
+    note: Any
+
+
+class LeetCodeResponse(BaseModel):
+    question: Question
+
+class LeetCode(BaseModel):
+    description: str
+    examples: list[str]
+    starter_code: str

deleetify/processor/leetcode/parser.py

@@ -0,0 +1,39 @@
+from deleetify.cli.lang_model import Lang
+from deleetify.processor.leetcode.exceptions import LeetCodeRequestParseError
+from deleetify.processor.leetcode.model import LeetCode, LeetCodeResponse
+from bs4 import BeautifulSoup # type: ignore[import]
+
+
+def parse_leetcode(leetcode_response: LeetCodeResponse, lang: Lang) -> LeetCode:
+    html_content = leetcode_response.question.content
+    soup = BeautifulSoup(html_content, "html.parser")
+
+    desciption = ""
+    for p in soup.find_all("p"):
+        # Skip empty paragraphs, "Constraints", and "Example X:" placeholders
+        text = p.get_text(strip=True)
+        if not text or "Constraints:" in text or "Example" in text:
+            continue
+        # Print the clean text of the description
+        desciption = p.get_text().strip()
+
+    examples: list[str] = []
+    for pre in soup.find_all("pre"):
+        # .get_text() extracts text inside <pre>, <strong>, etc., cleanly
+        # we split by lines and remove unnecessary leading/trailing spaces
+        lines = [line.strip() for line in pre.get_text().split("\\n") if line.strip()]
+
+        examples.append("\n".join(lines))
+
+    code_snp_list = list(
+        filter(lambda x: x.lang_slug == str(lang), leetcode_response.question.code_snippets)
+    )
+    if len(code_snp_list) == 0:
+        raise LeetCodeRequestParseError(f"Leetcode dont support {lang}")
+
+    code_snp = code_snp_list[0]
+    starter_code = code_snp.code
+
+    return LeetCode(
+        description=desciption, examples=examples, starter_code=starter_code
+    )

deleetify/processor/leetcode/request.py

@@ -0,0 +1,37 @@
+import logging
+import httpx # type: ignore[import]
+from pydantic import ValidationError # type: ignore[import]
+from deleetify.processor.leetcode.exceptions import (
+    LeetCodeRequestError,
+    LeetCodeRequestParseError,
+)
+from deleetify.processor.leetcode.model import LeetCodeResponse
+
+logger = logging.getLogger(__name__)
+
+BASE_URL = "https://alfa-leetcode-api.onrender.com/"
+
+
+def get_question_url(name: str):
+    return BASE_URL + f"select/raw?titleSlug={name}"
+
+
+def get_leetcode_response(name: str) -> LeetCodeResponse:
+    logging.info(f"Getting problem {name} from leetcode")
+    try:
+        response = httpx.get(get_question_url(name))
+        _ = response.raise_for_status()
+    except httpx.HTTPError as e:
+        logging.error(f"{e}")
+        raise LeetCodeRequestError(
+            "Something went wrong while fetching leetcode problem"
+        )
+
+    try:
+        response_json = response.json()
+        validated_resp = LeetCodeResponse.model_validate(response_json)
+    except ValidationError:
+        raise LeetCodeRequestParseError(
+            "Something went wrong in parsing leetcode response"
+        )
+    return validated_resp

deleetify/prompt/agent_prompt.py

@@ -0,0 +1,25 @@
+from deleetify.processor.leetcode.model import LeetCode
+
+
+def get_prompt(file_path: str, leetcode: LeetCode) -> str:
+    prompt = f"""
+Act as a raw text generator for an automated file-writing agent. Generate a clean, modern boilerplate script for the LeetCode problem description provided below, written in the target language of the starter code.
+
+Follow these structural requirements strictly:
+1. Include all necessary standard library imports and use modern idiomatic type definitions for the target language (avoid deprecated types or legacy wrappers like in python use `list`, `dict`, and `type | None` instead of 'List', 'Dict', 'Optional' respectively).
+2. Inside the primary class/module, implement a static method named bootstrap (or equivalent global runner function if the language is non-OOP). This method must accept parameters representing a single test case, instantiate the solution class, call the target function with those inputs, and clean-print both the inputs and the returned results to standard output.
+3. Keep the target solution method completely unimplemented (stubbed with a basic return or empty block), matching the signature of the original LeetCode starter code.
+4. Call the bootstrap method individually for each separate example test case at the entry point of the script (e.g., if there are 3 example test cases, call the bootstrap runner 3 distinct times with the respective arguments).
+
+Write this to @{file_path}
+
+Here is the problem details:
+{leetcode.description}
+
+{leetcode.examples}
+
+Starter code:
+{leetcode.starter_code}
+    """
+
+    return prompt

deleetify-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: deleetify
+Version: 0.1.0
+Summary: Makes local leetcode setup less painfull
+Author-email: "Dharshan.S" <me.dharshan.1@gmail.com>
+Maintainer-email: "Dharshan.S" <me.dharshan.1@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.13
+Requires-Dist: agent-client-protocol>=0.10.1
+Requires-Dist: beautifulsoup4>=4.15.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: typed-clap>=0.11.1
+Description-Content-Type: text/markdown
+
+# Deleetify
+
+> Makes local LeetCode setup less painful.
+
+A CLI tool that fetches any LeetCode problem and uses an AI agent to generate a ready-to-run boilerplate solution file — so you can jump straight into solving, not scaffolding.
+
+## Features
+
+- Fetch any LeetCode problem by name
+- AI-generated boilerplate via any ACP-compatible agent (e.g., opencode, claude-code)
+- Supports Python and JavaScript starter code
+- Configurable AI provider via TOML
+
+## Installation
+
+```bash
+pip install deleetify
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install deleetify
+```
+
+## Usage
+
+```bash
+# Basic usage — generates Python boilerplate
+deleetify "208. Implement Trie (Prefix Tree)"
+
+# Specify language
+deleetify "1. Two Sum" --lang javascript
+
+# Custom config path
+deleetify "15. 3Sum" --config ./my-agent.toml
+```
+
+## Configuration
+
+Deleetify uses a `deleetify.toml` to configure the AI provider. By default it looks for the file in the current directory.
+
+```toml
+[provider.opencode]
+command = "opencode"
+args = ["acp"]
+```
+
+If you have multiple providers, set a default:
+
+```toml
+[default]
+provider = "opencode"
+
+[provider.opencode]
+command = "opencode"
+args = ["acp"]
+
+[provider.gemini]
+command = "gemini"
+args = ["--acp"]
+# envs = {SOME_ENV = "value"}
+```
+
+## How it works
+
+1. You pass a LeetCode problem name (e.g., `"208. Implement Trie (Prefix Tree)"`)
+2. Deleetify parses the name and fetches the problem from the LeetCode API
+3. It scrapes the description, examples, and starter code from the HTML response
+4. It spawns an AI agent subprocess over the Agent Communication Protocol (ACP)
+5. The agent receives a prompt with the problem details and generates boilerplate code with built-in test cases
+6. The generated code is printed to stdout — pipe it to a file or your editor
+
+## Supported languages
+
+| CLI flag     | Language   |
+|--------------|------------|
+| `python3`    | Python 3   |
+| `javascript` | JavaScript |
+
+## Requirements
+
+- Python 3.13+
+- An ACP-compatible agent (e.g., [opencode](https://opencode.ai))
+
+## Development
+
+```bash
+git clone https://github.com/<user>/deleetify
+cd deleetify
+
+uv venv
+
+uv sync
+
+uv run deleetify "217. Contains Duplicate"
+```
+
+## License
+
+MIT

deleetify-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+deleetify/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deleetify/__main__.py,sha256=mao8uxciL-kURY_g9RljZZbidiwxcQKq5LkA6l5J8aY,129
+deleetify/main.py,sha256=0MRY_4d2WfppyJunDQQ02jlZUYaTPcIxZEQonu-TVc4,1899
+deleetify/acp_client/client.py,sha256=wBZx3t-daQvoiKUzgb6aG1dcLMxJh7uzmh_Dix1M7Qw,4473
+deleetify/acp_client/client_handler.py,sha256=U7aJLxYoj29poXznchKaW91mcdv-Ek5Ap3YOjV_JgsM,2739
+deleetify/acp_client/exceptions.py,sha256=yd2o-DcKWmv1XBrBFp4Y78QoyJPFiUDNOvfwp5jvBE8,118
+deleetify/cli/exceptions.py,sha256=LOrLU7zN7jw_5JokYKaP52UgmQs2pAA5Ww49O6wbURk,227
+deleetify/cli/lang_model.py,sha256=vCQA15aSkZy0lK1ZRi-3oE00WmTKroHub-NG5oE3n-I,241
+deleetify/cli/model.py,sha256=n4cMlCl9SzLyB9lcAFeE80Rp2wg0JocSnoYgaWoq2Kw,463
+deleetify/cli/parser.py,sha256=E6ZOka5Zn0xojWFSip28qIeTf-OjZzDeKhmTG34qrM0,377
+deleetify/file_name/exceptions.py,sha256=XrUkKBM4MWXBJyLcDD39D-1QPvlpczZMOwIHzWYYjCM,116
+deleetify/file_name/parser.py,sha256=kgUt9drm2_fxDNqMqry5plU281f-zmRcA87yQa-t2Ig,764
+deleetify/processor/config/exceptions.py,sha256=39-Zz3e1bXf9j80lXISkb0bnXFPQwuVEkbM-DSt9j3g,116
+deleetify/processor/config/model.py,sha256=TeVUIGQNYyi1Mto37buphQrCiNmcNaPBGtFzIJQuBoI,123
+deleetify/processor/config/parser.py,sha256=eK0haKcBUh4CvyeooLgU9LEjhPXB1QnYPGoiuWb8K9w,3781
+deleetify/processor/leetcode/exceptions.py,sha256=Y0oGxScckK35k6w5wHsU440fA1dpYEoDEx8MNEVmakY,246
+deleetify/processor/leetcode/model.py,sha256=XKY7TdLXnmkSch-Gsnbo3B4Ys2KuS4xiPEdMCEjAcGM,2465
+deleetify/processor/leetcode/parser.py,sha256=tCZBB6VMPXhOsYhJfTf4Gm-7EnvN2z0NYDJ8G-qmcUA,1537
+deleetify/processor/leetcode/request.py,sha256=Lm-rtwpxr0_NdJnDFIcvlodfsW5x7QA-cPkfPmgZGC8,1155
+deleetify/prompt/agent_prompt.py,sha256=r0PlMgFLKzs_RXBKtPoO1Iz0LzXkB1oDcARXk265AC4,1592
+deleetify-0.1.0.dist-info/METADATA,sha256=JTyGv_xp6vUnm9r2wgnnrBN6ys69mHGPUW0msxDRJEA,2891
+deleetify-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+deleetify-0.1.0.dist-info/entry_points.txt,sha256=7N8wmMTXvJxKa44Ws1y7ry2nmndVe5_uoovJ_9BSKcM,54
+deleetify-0.1.0.dist-info/RECORD,,

deleetify-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

deleetify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deleetify = deleetify.__main__:main