klaude-code 1.2.22__tar.gz → 1.2.23__tar.gz

{klaude_code-1.2.22 → klaude_code-1.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.22
+Version: 1.2.23
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -18,18 +18,23 @@ Requires-Dist: typer>=0.17.3
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 
-# Minimal Code Agent CLI (Klaude Code)
-
-An minimal and opinionated code agent with multi-model support.
-
-## Key Features
-- **Adaptive Tooling**: Model-aware toolsets (Claude Code tools for Sonnet, Codex `apply_patch` for GPT-5.1/Codex).
-- **Multi-Provider Support**: Compatible with `anthropic-messages-api`,`openai-responses-api`, and `openai-compatible-api`(`openrouter-api`),  featuring interleaved thinking, OpenRouter's provider sorting etc.
-- **Structured Sub-Agent Output**: Main agent defines output JSON schema for sub-agents; sub-agents use `report_back` tool with constrained decoding to return schema-compliant structured data.
-- **Skill System**: Extensible support for loading Claude Skills.
-- **Session Management**: Robust context preservation with resumable sessions (`--continue`).
-- **Simple TUI**: Clean interface offering full visibility into model responses, reasoning and actions.
-- **Core Utilities**: Slash commands, sub-agents, image pasting, terminal notifications, file mentioning, and auto-theming.
+# Klaude Code
+
+Multi-model code agent CLI.
+
+## Features
+- **Multi-provider**: Anthropic, OpenAI Responses API, OpenRouter
+- **Keep reasoning item in context**: Interleaved thinking support
+- **Model-aware tools**: Claude Code tools for Sonnet, `apply_patch` for GPT-5/Codex
+- **Structured sub-agent output**: Define JSON schema, get schema-compliant responses via constrained decoding
+- **Recursive `@file` mentions**: Circular dependency protection, relative path resolution
+- **Reminders**: Cooldown-based todo tracking and instruction reinforcement
+- **External file sync**: Monitoring for external edits (linter, manual)
+- **Interrupt handling**: Ctrl+C preserves partial responses and synthesizes tool cancellation results
+- **Output truncation**: Large outputs saved to file system with snapshot links
+- **Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
+- **Sessions**: Resumable with `--continue`
+- **Extras**: Slash commands, sub-agents, image paste, terminal notifications, auto-theming
 
 ## Installation
 

{klaude_code-1.2.22 → klaude_code-1.2.23}/README.md

@@ -1,15 +1,20 @@
-# Minimal Code Agent CLI (Klaude Code)
-
-An minimal and opinionated code agent with multi-model support.
-
-## Key Features
-- **Adaptive Tooling**: Model-aware toolsets (Claude Code tools for Sonnet, Codex `apply_patch` for GPT-5.1/Codex).
-- **Multi-Provider Support**: Compatible with `anthropic-messages-api`,`openai-responses-api`, and `openai-compatible-api`(`openrouter-api`),  featuring interleaved thinking, OpenRouter's provider sorting etc.
-- **Structured Sub-Agent Output**: Main agent defines output JSON schema for sub-agents; sub-agents use `report_back` tool with constrained decoding to return schema-compliant structured data.
-- **Skill System**: Extensible support for loading Claude Skills.
-- **Session Management**: Robust context preservation with resumable sessions (`--continue`).
-- **Simple TUI**: Clean interface offering full visibility into model responses, reasoning and actions.
-- **Core Utilities**: Slash commands, sub-agents, image pasting, terminal notifications, file mentioning, and auto-theming.
+# Klaude Code
+
+Multi-model code agent CLI.
+
+## Features
+- **Multi-provider**: Anthropic, OpenAI Responses API, OpenRouter
+- **Keep reasoning item in context**: Interleaved thinking support
+- **Model-aware tools**: Claude Code tools for Sonnet, `apply_patch` for GPT-5/Codex
+- **Structured sub-agent output**: Define JSON schema, get schema-compliant responses via constrained decoding
+- **Recursive `@file` mentions**: Circular dependency protection, relative path resolution
+- **Reminders**: Cooldown-based todo tracking and instruction reinforcement
+- **External file sync**: Monitoring for external edits (linter, manual)
+- **Interrupt handling**: Ctrl+C preserves partial responses and synthesizes tool cancellation results
+- **Output truncation**: Large outputs saved to file system with snapshot links
+- **Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
+- **Sessions**: Resumable with `--continue`
+- **Extras**: Slash commands, sub-agents, image paste, terminal notifications, auto-theming
 
 ## Installation
 

{klaude_code-1.2.22 → klaude_code-1.2.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.22"
+version = "1.2.23"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -81,6 +81,7 @@ layers = [
     "klaude_code.cli",
     "klaude_code.ui",
     "klaude_code.core",
+    "klaude_code.skill",
     "klaude_code.command",
     "klaude_code.session",
     "klaude_code.config",

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/command/status_cmd.py

@@ -22,7 +22,7 @@ def accumulate_session_usage(session: Session) -> AggregatedUsage:
     for item in session.conversation_history:
         if isinstance(item, model.TaskMetadataItem):
             task_count += 1
-            all_metadata.append(item.main)
+            all_metadata.append(item.main_agent)
             all_metadata.extend(item.sub_agent_task_metadata)
 
     # Aggregate by model+provider

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/const/__init__.py

@@ -90,10 +90,10 @@ INVALID_TOOL_CALL_MAX_LENGTH = 500
 TRUNCATE_DISPLAY_MAX_LINE_LENGTH = 1000
 
 # Maximum lines for truncated display output
-TRUNCATE_DISPLAY_MAX_LINES = 20
+TRUNCATE_DISPLAY_MAX_LINES = 8
 
 # Maximum lines for sub-agent result display
-SUB_AGENT_RESULT_MAX_LINES = 12
+SUB_AGENT_RESULT_MAX_LINES = 20
 
 
 # UI refresh rate (frames per second) for debounced content streaming
@@ -102,6 +102,12 @@ UI_REFRESH_RATE_FPS = 20
 # Number of lines to keep visible at bottom of markdown streaming window
 MARKDOWN_STREAM_LIVE_WINDOW = 6
 
+# Left margin (columns) to reserve when rendering markdown
+MARKDOWN_LEFT_MARGIN = 2
+
+# Right margin (columns) to reserve when rendering markdown
+MARKDOWN_RIGHT_MARGIN = 2
+
 # Status hint text shown after spinner status
 STATUS_HINT_TEXT = " (esc to interrupt)"
 

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/core/manager/sub_agent_manager.py

@@ -89,7 +89,7 @@ Only the content passed to `report_back` will be returned to user.\
                     result = event.task_result
                 # Capture TaskMetadataEvent for metadata propagation
                 elif isinstance(event, events.TaskMetadataEvent):
-                    task_metadata = event.metadata.main
+                    task_metadata = event.metadata.main_agent
                 await self.emit_event(event)
             return SubAgentResult(
                 task_result=result,

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/core/reminders.py

@@ -12,6 +12,7 @@ from klaude_code.core.tool import BashTool, ReadTool, reset_tool_context, set_to
 from klaude_code.core.tool.file._utils import hash_text_sha256
 from klaude_code.protocol import model, tools
 from klaude_code.session import Session
+from klaude_code.skill import get_skill
 
 type Reminder = Callable[[Session], Awaitable[model.DeveloperMessageItem | None]]
 
@@ -19,6 +20,9 @@ type Reminder = Callable[[Session], Awaitable[model.DeveloperMessageItem | None]
 # Match @ preceded by whitespace, start of line, or → (ReadTool line number arrow)
 AT_FILE_PATTERN = re.compile(r'(?:(?<!\S)|(?<=\u2192))@("(?P<quoted>[^\"]+)"|(?P<plain>\S+))')
 
+# Match $skill or ¥skill at the beginning of the first line
+SKILL_PATTERN = re.compile(r"^[$¥](?P<skill>\S+)")
+
 
 def get_last_new_user_input(session: Session) -> str | None:
     """Get last user input & developer message (CLAUDE.md) from conversation history. if there's a tool result after user input, return None"""
@@ -73,6 +77,21 @@ def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
     return patterns
 
 
+def get_skill_from_user_input(session: Session) -> str | None:
+    """Get $skill reference from the first line of last user input."""
+    for item in reversed(session.conversation_history):
+        if isinstance(item, model.ToolResultItem):
+            return None
+        if isinstance(item, model.UserMessageItem):
+            content = item.content or ""
+            first_line = content.split("\n", 1)[0]
+            m = SKILL_PATTERN.match(first_line)
+            if m:
+                return m.group("skill")
+            return None
+    return None
+
+
 async def _load_at_file_recursive(
     session: Session,
     pattern: str,
@@ -373,6 +392,36 @@ async def image_reminder(session: Session) -> model.DeveloperMessageItem | None:
     )
 
 
+async def skill_reminder(session: Session) -> model.DeveloperMessageItem | None:
+    """Load skill content when user references a skill with $skill syntax."""
+    skill_name = get_skill_from_user_input(session)
+    if not skill_name:
+        return None
+
+    # Get the skill from skill module
+    skill = get_skill(skill_name)
+    if not skill:
+        return None
+
+    # Get base directory from skill_path
+    base_dir = str(skill.skill_path.parent) if skill.skill_path else "unknown"
+
+    content = f"""<system-reminder>The user activated the "{skill.name}" skill. Here is the skill content:
+
+<skill>
+<name>{skill.name}</name>
+<base_dir>{base_dir}</base_dir>
+
+{skill.to_prompt()}
+</skill>
+</system-reminder>"""
+
+    return model.DeveloperMessageItem(
+        content=content,
+        skill_name=skill.name,
+    )
+
+
 def _is_memory_loaded(session: Session, path: str) -> bool:
     """Check if a memory file has already been loaded (tracked with is_memory=True)."""
     status = session.file_tracker.get(path)
@@ -510,6 +559,7 @@ ALL_REMINDERS = [
     last_path_memory_reminder,
     at_file_reader_reminder,
     image_reminder,
+    skill_reminder,
 ]
 
 
@@ -540,6 +590,7 @@ def load_agent_reminders(
             last_path_memory_reminder,
             file_changed_externally_reminder,
             image_reminder,
+            skill_reminder,
         ]
     )
 

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/core/task.py

@@ -25,7 +25,7 @@ class MetadataAccumulator:
     """
 
     def __init__(self, model_name: str) -> None:
-        self._main = model.TaskMetadata(model_name=model_name)
+        self._main_agent = model.TaskMetadata(model_name=model_name)  # Main agent metadata
         self._sub_agent_metadata: list[model.TaskMetadata] = []
         self._throughput_weighted_sum: float = 0.0
         self._throughput_tracked_tokens: int = 0
@@ -36,13 +36,12 @@ class MetadataAccumulator:
     def add(self, turn_metadata: model.ResponseMetadataItem) -> None:
         """Merge a turn's metadata into the accumulated state."""
         self._turn_count += 1
-        main = self._main
         usage = turn_metadata.usage
 
         if usage is not None:
-            if main.usage is None:
-                main.usage = model.Usage()
-            acc_usage = main.usage
+            if self._main_agent.usage is None:
+                self._main_agent.usage = model.Usage()
+            acc_usage = self._main_agent.usage
 
             model.TaskMetadata.merge_usage(acc_usage, usage)
             acc_usage.currency = usage.currency
@@ -63,9 +62,9 @@ class MetadataAccumulator:
                     self._throughput_tracked_tokens += current_output
 
         if turn_metadata.provider is not None:
-            main.provider = turn_metadata.provider
+            self._main_agent.provider = turn_metadata.provider
         if turn_metadata.model_name:
-            main.model_name = turn_metadata.model_name
+            self._main_agent.model_name = turn_metadata.model_name
 
     def add_sub_agent_metadata(self, sub_agent_metadata: model.TaskMetadata) -> None:
         """Add sub-agent task metadata to the accumulated state."""
@@ -73,21 +72,22 @@ class MetadataAccumulator:
 
     def finalize(self, task_duration_s: float) -> model.TaskMetadataItem:
         """Return the final accumulated metadata with computed throughput and duration."""
-        main = self._main
-        if main.usage is not None:
+        if self._main_agent.usage is not None:
             if self._throughput_tracked_tokens > 0:
-                main.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
+                self._main_agent.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
             else:
-                main.usage.throughput_tps = None
+                self._main_agent.usage.throughput_tps = None
 
             if self._first_token_latency_count > 0:
-                main.usage.first_token_latency_ms = self._first_token_latency_sum / self._first_token_latency_count
+                self._main_agent.usage.first_token_latency_ms = (
+                    self._first_token_latency_sum / self._first_token_latency_count
+                )
             else:
-                main.usage.first_token_latency_ms = None
+                self._main_agent.usage.first_token_latency_ms = None
 
-        main.task_duration_s = task_duration_s
-        main.turn_count = self._turn_count
-        return model.TaskMetadataItem(main=main, sub_agent_task_metadata=self._sub_agent_metadata)
+        self._main_agent.task_duration_s = task_duration_s
+        self._main_agent.turn_count = self._turn_count
+        return model.TaskMetadataItem(main_agent=self._main_agent, sub_agent_task_metadata=self._sub_agent_metadata)
 
 
 @dataclass
@@ -126,17 +126,28 @@ class TaskExecutor:
         self._context = context
         self._current_turn: TurnExecutor | None = None
         self._started_at: float = 0.0
+        self._metadata_accumulator: MetadataAccumulator | None = None
 
     @property
     def current_turn(self) -> TurnExecutor | None:
         return self._current_turn
 
     def cancel(self) -> list[events.Event]:
-        """Cancel the current turn and return any resulting events."""
+        """Cancel the current turn and return any resulting events including metadata."""
         ui_events: list[events.Event] = []
         if self._current_turn is not None:
             ui_events.extend(self._current_turn.cancel())
             self._current_turn = None
+
+        # Emit partial metadata on cancellation
+        if self._metadata_accumulator is not None and self._started_at > 0:
+            task_duration_s = time.perf_counter() - self._started_at
+            accumulated = self._metadata_accumulator.finalize(task_duration_s)
+            if accumulated.main_agent.usage is not None:
+                session_id = self._context.session_ctx.session_id
+                ui_events.append(events.TaskMetadataEvent(metadata=accumulated, session_id=session_id))
+                self._context.session_ctx.append_history([accumulated])
+
         return ui_events
 
     async def run(self, user_input: model.UserInputPayload) -> AsyncGenerator[events.Event]:
@@ -152,7 +163,8 @@ class TaskExecutor:
         del user_input  # Persisted by the operation handler before launching the task.
 
         profile = ctx.profile
-        metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)
+        self._metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)
+        metadata_accumulator = self._metadata_accumulator
 
         while True:
             # Process reminders at the start of each turn
@@ -226,6 +238,13 @@ class TaskExecutor:
                 return
 
             if turn is None or turn.task_finished:
+                # Sub-agent with empty result should retry instead of finishing
+                if ctx.sub_agent_state is not None and turn is not None and not turn.task_result.strip():
+                    yield events.ErrorEvent(
+                        error_message="Sub-agent returned empty result, retrying...",
+                        can_retry=True,
+                    )
+                    continue
                 break
 
         # Finalize metadata

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/core/tool/__init__.py

@@ -3,11 +3,10 @@ from .file.apply_patch_tool import ApplyPatchTool
 from .file.edit_tool import EditTool
 from .file.read_tool import ReadTool
 from .file.write_tool import WriteTool
-from .memory.skill_loader import Skill, SkillLoader
-from .memory.skill_tool import SkillTool
 from .report_back_tool import ReportBackTool
 from .shell.bash_tool import BashTool
 from .shell.command_safety import SafetyCheckResult, is_safe_command
+from .skill.skill_tool import SkillTool
 from .sub_agent_tool import SubAgentTool
 from .todo.todo_write_tool import TodoWriteTool
 from .todo.update_plan_tool import UpdatePlanTool
@@ -40,8 +39,6 @@ __all__ = [
     "ReportBackTool",
     "SafetyCheckResult",
     "SimpleTruncationStrategy",
-    "Skill",
-    "SkillLoader",
     "SkillTool",
     "SubAgentTool",
     "TodoContext",

{klaude_code-1.2.22/src/klaude_code/core/tool/memory → klaude_code-1.2.23/src/klaude_code/core/tool/skill}/skill_tool.py

@@ -1,38 +1,22 @@
+"""SkillTool - Tool for agent to activate and load skills."""
+
 from pathlib import Path
 
 from pydantic import BaseModel
 
-from klaude_code.core.tool.memory.skill_loader import SkillLoader
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
+from klaude_code.skill import get_available_skills, get_skill, list_skill_names
 
 
 @register(tools.SKILL)
 class SkillTool(ToolABC):
-    """Tool to execute/load a skill within the main conversation"""
-
-    _skill_loader: SkillLoader | None = None
-    _discovery_done: bool = False
-
-    @classmethod
-    def set_skill_loader(cls, loader: SkillLoader) -> None:
-        """Set the skill loader instance"""
-        cls._skill_loader = loader
-        cls._discovery_done = False
-
-    @classmethod
-    def _ensure_skills_discovered(cls) -> None:
-        if cls._discovery_done:
-            return
-        if cls._skill_loader is not None:
-            cls._skill_loader.discover_skills()
-        cls._discovery_done = True
+    """Tool to execute/load a skill within the main conversation."""
 
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:
-        """Generate schema with embedded available skills metadata"""
-        cls._ensure_skills_discovered()
+        """Generate schema with embedded available skills metadata."""
         skills_xml = cls._generate_skills_xml()
 
         return llm_param.ToolSchema(
@@ -53,16 +37,17 @@ class SkillTool(ToolABC):
 
     @classmethod
     def _generate_skills_xml(cls) -> str:
-        """Generate XML format skills metadata"""
-        if not cls._skill_loader:
+        """Generate XML format skills metadata."""
+        skills = get_available_skills()
+        if not skills:
             return ""
 
         xml_parts: list[str] = []
-        for skill in cls._skill_loader.loaded_skills.values():
+        for name, description, location in skills:
             xml_parts.append(f"""<skill>
-<name>{skill.name}</name>
-<description>{skill.description}</description>
-<location>{skill.location}</location>
+<name>{name}</name>
+<description>{description}</description>
+<location>{location}</location>
 </skill>""")
         return "\n".join(xml_parts)
 
@@ -71,7 +56,7 @@ class SkillTool(ToolABC):
 
     @classmethod
     async def call(cls, arguments: str) -> model.ToolResultItem:
-        """Load and return full skill content"""
+        """Load and return full skill content."""
         try:
             args = cls.SkillArguments.model_validate_json(arguments)
         except ValueError as e:
@@ -80,18 +65,10 @@ class SkillTool(ToolABC):
                 output=f"Invalid arguments: {e}",
             )
 
-        cls._ensure_skills_discovered()
-
-        if not cls._skill_loader:
-            return model.ToolResultItem(
-                status="error",
-                output="Skill loader not initialized",
-            )
-
-        skill = cls._skill_loader.get_skill(args.command)
+        skill = get_skill(args.command)
 
         if not skill:
-            available = ", ".join(cls._skill_loader.list_skills())
+            available = ", ".join(list_skill_names())
             return model.ToolResultItem(
                 status="error",
                 output=f"Skill '{args.command}' does not exist. Available skills: {available}",
@@ -101,7 +78,7 @@ class SkillTool(ToolABC):
         base_dir = str(skill.skill_path.parent) if skill.skill_path else "unknown"
 
         # Return with loading message format
-        result = f"""<command-message>The "{skill.name}" skill is running</command-message>
+        result = f"""<command-message>The "{skill.name}" skill is activated</command-message>
 <command-name>{skill.name}</command-name>
 
 Base directory for this skill: {base_dir}

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/protocol/model.py

@@ -230,6 +230,7 @@ class DeveloperMessageItem(BaseModel):
     at_files: list[AtPatternParseResult] | None = None
     command_output: CommandOutput | None = None
     user_image_count: int | None = None
+    skill_name: str | None = None  # Skill name activated via $skill syntax
 
 
 class ImageURLPart(BaseModel):
@@ -417,7 +418,7 @@ class TaskMetadata(BaseModel):
 class TaskMetadataItem(BaseModel):
     """Aggregated metadata for a complete task, stored in conversation history."""
 
-    main: TaskMetadata = Field(default_factory=TaskMetadata)
+    main_agent: TaskMetadata = Field(default_factory=TaskMetadata)  # Main agent metadata
     sub_agent_task_metadata: list[TaskMetadata] = Field(default_factory=lambda: list[TaskMetadata]())
     created_at: datetime = Field(default_factory=datetime.now)
 

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/session/export.py

@@ -235,7 +235,7 @@ def _render_metadata_item(item: model.TaskMetadataItem) -> str:
     lines: list[str] = []
 
     # Main agent metadata
-    lines.append(_render_single_metadata(item.main, indent=0, show_context=True))
+    lines.append(_render_single_metadata(item.main_agent, indent=0, show_context=True))
 
     # Sub-agent metadata with indent
     for sub in item.sub_agent_task_metadata:

{klaude_code-1.2.22 → klaude_code-1.2.23}/src/klaude_code/session/store.py

@@ -205,11 +205,13 @@ def build_meta_snapshot(
         "work_dir": str(work_dir),
         "sub_agent_state": sub_agent_state.model_dump(mode="json") if sub_agent_state else None,
         "file_tracker": {path: status.model_dump(mode="json") for path, status in file_tracker.items()},
-        "todos": [todo.model_dump(mode="json") for todo in todos],
+        "todos": [todo.model_dump(mode="json", exclude_defaults=True) for todo in todos],
         "created_at": created_at,
         "updated_at": updated_at,
         "messages_count": messages_count,
         "model_name": model_name,
         "model_config_name": model_config_name,
-        "model_thinking": model_thinking.model_dump(mode="json") if model_thinking else None,
+        "model_thinking": model_thinking.model_dump(mode="json", exclude_defaults=True, exclude_none=True)
+        if model_thinking
+        else None,
     }

klaude_code-1.2.23/src/klaude_code/skill/__init__.py

@@ -0,0 +1,27 @@
+"""Skill module - independent skill management system.
+
+This module provides the core skill functionality:
+- Skill discovery and loading from multiple directories
+- System skill installation
+- Global skill access via manager functions
+
+Public API:
+- get_skill(name) - Get a skill by name
+- get_available_skills() - Get list of (name, description, location) tuples
+- get_skill_loader() - Get the global SkillLoader instance
+- list_skill_names() - Get list of skill names
+- Skill - Skill data class
+- SkillLoader - Skill loader class
+"""
+
+from klaude_code.skill.loader import Skill, SkillLoader
+from klaude_code.skill.manager import get_available_skills, get_skill, get_skill_loader, list_skill_names
+
+__all__ = [
+    "Skill",
+    "SkillLoader",
+    "get_available_skills",
+    "get_skill",
+    "get_skill_loader",
+    "list_skill_names",
+]

klaude_code-1.2.23/src/klaude_code/skill/assets/deslop/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: deslop
+description: Remove AI-generated code slop from files or diffs. Use this skill when reviewing AI-generated code to clean up unnecessary comments, defensive code, type hacks, and style inconsistencies. Triggers include "deslop", "remove slop", "clean up AI code", "review for slop".
+metadata:
+  short-description: Remove AI code slop
+---
+
+# Deslop
+
+Remove AI-generated slop from code. Check the specified files or diff and remove:
+
+- Extra comments that a human wouldn't add or are inconsistent with the rest of the file
+- Extra defensive checks or try/catch blocks that are abnormal for that area of the codebase (especially if called by trusted/validated codepaths)
+- Casts to `any` or `# type: ignore` to get around type issues
+- Any other style that is inconsistent with the file
+
+Report at the end with only a 1-3 sentence summary of what you changed.