lazyopencode 0.1.0__tar.gz

lazyopencode-0.1.0/.github/release-drafter.yml

@@ -0,0 +1,13 @@
+name-template: "$RESOLVED_VERSION"
+tag-template: "$RESOLVED_VERSION"
+change-template: "- $TITLE by @$AUTHOR (#$NUMBER)"
+no-changes-template: "- No changes"
+
+template: |
+  ## Changes
+
+  $CHANGES
+
+  ## Contributors
+
+  $CONTRIBUTORS

lazyopencode-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - name: Install dependencies
+        run: uv sync --all-extras
+      - name: Lint
+        run: uv run ruff check src tests
+      - name: Format check
+        run: uv run ruff format --check src tests
+      - name: Type check
+        run: uv run mypy src
+      - name: Test
+        run: uv run pytest

lazyopencode-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,23 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Important for hatch-vcs versioning
+      - uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+      - name: Build
+        run: uv build
+      - name: Publish to PyPI
+        run: uv publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_KEY }}

lazyopencode-0.1.0/.github/workflows/release-drafter.yml

@@ -0,0 +1,16 @@
+name: Release Drafter
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  update_release_draft:
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: release-drafter/release-drafter@v6
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

lazyopencode-0.1.0/.gitignore

@@ -0,0 +1,73 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# uv
+.uv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# Type checking
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+*.env
+
+# Logs
+*.log
+
+# Textual snapshots (keep in repo but ignore local changes during dev)
+# tests/snapshots/*.svg
+
+# backlog.md special folder
+backlog
+
+# Plans folder (keep in filesystem, don't track)
+_plans/
+
+# hatch-vcs generated version file
+src/lazyopencode/_version.py

lazyopencode-0.1.0/.opencode/command/commit.md

@@ -0,0 +1,36 @@
+---
+description: Create a git commit
+---
+Create a git commit $ARGUMENTS.
+
+Process:
+1. Check for staged changes (!`git status`)
+2. If no staged changes, review and stage appropriate files
+3. Run pre-commit checks (unless --no-verify is in $ARGUMENTS)
+4. Analyze changes to determine commit type
+5. Generate descriptive commit message
+6. Include scope if applicable: `type(scope): description`
+7. Add body for complex changes explaining why
+8. NOTE: Exclude Claude co-authorship footer from commits
+9. Execute commit
+
+Commit Types:
+- ✨ feat: New features
+- 🐛 fix: Bug fixes
+- 📝 docs: Documentation changes
+- ♻️ refactor: Code restructuring without changing functionality
+- 🎨 style: Code formatting, missing semicolons, etc.
+- ⚡️ perf: Performance improvements
+- ✅ test: Adding or correcting tests
+- 🧑‍💻 chore: Tooling, configuration, maintenance
+- 🚧 wip: Work in progress
+- 🔥 remove: Removing code or files
+- 🚑 hotfix: Critical fixes
+- 🔒 security: Security improvements
+
+Best Practices:
+- Keep commits atomic and focused
+- Write in imperative mood ("Add feature" not "Added feature")
+- Explain why, not just what
+- Reference issues/PRs when relevant
+- Split unrelated changes into separate commits

lazyopencode-0.1.0/.opencode/command/run-quality-gates.md

@@ -0,0 +1,6 @@
+---
+allowed-tools: Skill(quality-gates)
+description: Run code quality checks (lint, format, type check, tests)
+---
+
+Invoke the `quality-gates` skill to run linting, formatting, type checking, and tests.

lazyopencode-0.1.0/.opencode/plugin/compaction.ts

@@ -0,0 +1,21 @@
+/**
+ * Compaction Plugin - customizes context during session compaction.
+ *
+ * This plugin demonstrates using the 'experimental.session.compacting' hook
+ * to inject additional context when a session is compacted.
+ */
+import type { Plugin } from "@opencode-ai/plugin"
+
+export const CompactionPlugin: Plugin = async (ctx) => {
+  return {
+    "experimental.session.compacting": async (input, output) => {
+      // Inject additional context into the compaction prompt
+      output.context.push(`## Custom Context
+
+Include any state that should persist across compaction:
+- Current task status
+- Important decisions made
+- Files being actively worked on`)
+    },
+  }
+}

lazyopencode-0.1.0/.opencode/plugin/custom-tools.ts

@@ -0,0 +1,31 @@
+/**
+ * Custom Tools Plugin - demonstrates adding custom tools via plugin.
+ *
+ * Plugins can define their own tools that OpenCode can call,
+ * alongside the built-in tools.
+ */
+import { type Plugin, tool } from "@opencode-ai/plugin"
+
+export const CustomToolsPlugin: Plugin = async (ctx) => {
+  return {
+    tool: {
+      greet: tool({
+        description: "Greets a user by name",
+        args: {
+          name: tool.schema.string(),
+        },
+        async execute(args, ctx) {
+          return `Hello ${args.name}! Welcome to OpenCode.`
+        },
+      }),
+
+      timestamp: tool({
+        description: "Returns the current timestamp",
+        args: {},
+        async execute(args, ctx) {
+          return new Date().toISOString()
+        },
+      }),
+    },
+  }
+}

lazyopencode-0.1.0/.opencode/plugin/env-protection.ts

@@ -0,0 +1,21 @@
+/**
+ * Environment Protection Plugin - prevents reading .env files.
+ *
+ * This plugin demonstrates using the 'tool.execute.before' hook
+ * to intercept and block certain tool operations.
+ */
+export const EnvProtection = async ({
+  project,
+  client,
+  $,
+  directory,
+  worktree,
+}) => {
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (input.tool === "read" && output.args.filePath.includes(".env")) {
+        throw new Error("Do not read .env files")
+      }
+    },
+  }
+}

lazyopencode-0.1.0/.opencode/plugin/notification.ts

@@ -0,0 +1,24 @@
+/**
+ * Notification Plugin - sends system notifications on session events.
+ *
+ * This plugin demonstrates using the 'event' handler to respond
+ * to OpenCode events like session.idle.
+ */
+export const NotificationPlugin = async ({
+  project,
+  client,
+  $,
+  directory,
+  worktree,
+}) => {
+  console.log("NotificationPlugin initialized!")
+
+  return {
+    event: async ({ event }) => {
+      // Send notification on session completion
+      if (event.type === "session.idle") {
+        await $`osascript -e 'display notification "Session completed!" with title "opencode"'`
+      }
+    },
+  }
+}

lazyopencode-0.1.0/.opencode/skill/quality-gates/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: quality-gates
+description: This skill should be used when the user wants to run code quality checks (linting, formatting, type checking, tests) on the lazyopencode project. Use this skill when asked to "run quality gates", "check the code", "run tests", "lint the code", or verify code quality before committing.
+---
+
+# Quality Gates
+
+Run code quality checks for the lazyopencode project. This skill executes the same checks used in pre-commit hooks plus tests.
+
+## Quality Checks
+
+The following checks are run in order:
+
+| Check | Command | Purpose |
+|-------|---------|---------|
+| **Ruff Lint** | `uv run ruff check src tests --fix` | Lint code and auto-fix issues |
+| **Ruff Format** | `uv run ruff format src tests` | Format code consistently |
+| **Mypy** | `uv run mypy src` | Static type checking |
+| **Pytest** | `uv run pytest tests/ -q` | Run test suite |
+
+## Usage
+
+To run all quality gates:
+
+```bash
+scripts/check_quality.sh
+```
+
+Or run individual checks as needed using the commands above.
+
+## Workflow
+
+1. Run the `scripts/check_quality.sh` script from the project root
+2. Review any failures and fix issues
+3. Re-run until all checks pass
+4. Present user with concise summary of results in markdown table format
+
+## Common Issues
+
+- **Ruff lint failures**: Usually auto-fixed. If not, check the error message for manual fixes needed.
+- **Mypy errors**: Type annotation issues. Add or fix type hints as indicated.
+- **Test failures**: Review test output, fix failing tests or underlying code.

lazyopencode-0.1.0/.opencode/tool/database.ts

@@ -0,0 +1,12 @@
+import { tool } from "@opencode-ai/plugin"
+
+export default tool({
+  description: "Query the project database",
+  args: {
+    query: tool.schema.string().describe("SQL query to execute"),
+  },
+  async execute(args) {
+    // Your database logic here
+    return `Executed query: ${args.query}`
+  },
+})

lazyopencode-0.1.0/.opencode/tool/math.ts

@@ -0,0 +1,39 @@
+import { tool } from "@opencode-ai/plugin"
+
+// Multiple exports create separate tools: math_add, math_multiply, math_divide
+
+export const add = tool({
+  description: "Add two numbers",
+  args: {
+    a: tool.schema.number().describe("First number"),
+    b: tool.schema.number().describe("Second number"),
+  },
+  async execute(args) {
+    return args.a + args.b
+  },
+})
+
+export const multiply = tool({
+  description: "Multiply two numbers",
+  args: {
+    a: tool.schema.number().describe("First number"),
+    b: tool.schema.number().describe("Second number"),
+  },
+  async execute(args) {
+    return args.a * args.b
+  },
+})
+
+export const divide = tool({
+  description: "Divide two numbers",
+  args: {
+    a: tool.schema.number().describe("Dividend"),
+    b: tool.schema.number().describe("Divisor"),
+  },
+  async execute(args) {
+    if (args.b === 0) {
+      throw new Error("Cannot divide by zero")
+    }
+    return args.a / args.b
+  },
+})

lazyopencode-0.1.0/.opencode/tool/project-info.ts

@@ -0,0 +1,11 @@
+import { tool } from "@opencode-ai/plugin"
+
+export default tool({
+  description: "Get project information from context",
+  args: {},
+  async execute(args, context) {
+    // Access context information
+    const { agent, sessionID, messageID } = context
+    return `Agent: ${agent}, Session: ${sessionID}, Message: ${messageID}`
+  },
+})

lazyopencode-0.1.0/.opencode/tool/python-runner.ts

@@ -0,0 +1,17 @@
+import { tool } from "@opencode-ai/plugin"
+
+// Example: Tool that invokes a Python script
+// The tool definition is TypeScript, but execution can use any language
+
+export default tool({
+  description: "Run a Python script with arguments",
+  args: {
+    script: tool.schema.string().describe("Path to Python script"),
+    args: tool.schema.array(tool.schema.string()).describe("Arguments to pass"),
+  },
+  async execute(args) {
+    const scriptArgs = args.args.join(" ")
+    const result = await Bun.$`python3 ${args.script} ${scriptArgs}`.text()
+    return result.trim()
+  },
+})

lazyopencode-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.6
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: local
+    hooks:
+      - id: mypy
+        name: mypy
+        entry: uv run mypy src
+        language: system
+        types: [python]
+        pass_filenames: false

lazyopencode-0.1.0/AGENTS.md

@@ -0,0 +1,173 @@
+# LazyOpenCode
+
+A keyboard-driven TUI for visualizing and managing OpenCode customizations.
+
+## Environment Rules
+- **OS**: Windows (Git Bash). Use forward slashes `/` and `/c/` prefix for absolute paths.
+- **Search**: `rg` and `fd` are installed. Use them for fast searching.
+- **Quality Gates**: Always run quality gates before asking the user to commit changes. Use the `quality-gates` skill by calling the Skill tool. Do NOT run `uv run ruff`, `uv run mypy`, or other individual linting tools directly - always use the skill instead.
+- **TUI Verification**: Do NOT run `uv run lazyopencode` to verify the application. It is a TUI and output cannot be captured effectively. Use unit tests or static analysis instead.
+
+## Project Overview
+
+- **Language**: Python 3.11+
+- **Framework**: Textual (TUI), Rich (terminal formatting)
+- **Package Manager**: uv
+- **Architecture**: Mixin-based Textual app with service layer
+- **Inspired by**: LazyClaude, Lazygit
+
+## Implementation Status (Phases 0-5 Completed)
+
+- [x] **Foundation**: Project structure, dependencies, CLI entry point
+- [x] **Models**: Customization types, data classes
+- [x] **Widgets**: Type panels, combined panel, detail pane, status bar, footer
+- [x] **Parsers**: Full support for Commands, Agents, Skills, Rules, MCPs, Tools, Plugins
+- [x] **Navigation**: Vim-like navigation (j/k), tab switching, number shortcuts
+- [x] **Filtering**: Filter by Global/Project, Search overlay
+- [x] **Theme**: Gruvbox theme (default) matching LazyClaude style
+- [ ] **Polish**: Settings persistence, comprehensive tests (In Progress)
+
+## Quick Start
+
+```bash
+# Run the application
+uv run lazyopencode
+
+# Run tests
+uv run pytest
+
+# Run quality gates (linting, formatting, type checking, tests)
+bash scripts/check_quality.sh
+```
+
+## Directory Structure
+
+```
+src/lazyopencode/
+├── app.py           # Main Textual application
+├── bindings.py      # Keyboard bindings
+├── themes.py        # Theme definitions
+├── models/          # Data models (Customization, ConfigLevel, etc.)
+├── services/        # Business logic
+│   ├── discovery.py # Finds customizations on disk
+│   ├── filter.py    # Filters by level/query
+│   └── parsers/     # Type-specific parsers
+├── widgets/         # Textual UI components
+├── mixins/          # App functionality mixins
+└── styles/          # TCSS stylesheets
+```
+
+## Code Standards
+
+### Python Style
+- Use type hints for all function parameters and return values
+- Use `dataclasses` for data models
+- Follow PEP 8 naming conventions
+- Maximum line length: 88 characters (ruff default)
+
+### Textual Patterns
+- Use `reactive` for state that should trigger UI updates
+- Use `Message` classes for widget communication
+- Use mixins to organize app functionality
+- Keep widgets focused and single-purpose
+
+### Imports
+- Group imports: stdlib, third-party, local
+- Use absolute imports within the package
+- Re-export public APIs from `__init__.py`
+
+## OpenCode Configuration Paths
+
+The application discovers customizations from these locations:
+
+| Type | Global Path | Project Path |
+|------|-------------|--------------|
+| Commands | `~/.config/opencode/command/*.md` | `.opencode/command/*.md` |
+| Agents | `~/.config/opencode/agent/*.md` | `.opencode/agent/*.md` |
+| Skills | `~/.config/opencode/skill/*/SKILL.md` | `.opencode/skill/*/SKILL.md` |
+| Rules | `~/.config/opencode/AGENTS.md` | `AGENTS.md` |
+| MCPs | `~/.config/opencode/opencode.json` | `opencode.json` |
+| Tools | `~/.config/opencode/tool/*.ts` | `.opencode/tool/*.ts` |
+| Plugins | `~/.config/opencode/plugin/` | `.opencode/plugin/` |
+
+## Key Components
+
+### Models (`models/customization.py`)
+- `Customization` - Core data object for any customization
+- `ConfigLevel` - Enum: GLOBAL, PROJECT
+- `CustomizationType` - Enum: COMMAND, AGENT, SKILL, RULES, MCP, TOOL, PLUGIN
+
+### Services
+- `ConfigDiscoveryService` - Scans filesystem, uses parsers
+- `FilterService` - Filters by level and search query
+- `ICustomizationParser` - Protocol for type-specific parsers
+
+### Widgets
+- `TypePanel` - List panel with selection
+- `CombinedPanel` - Tabbed panel for multiple types
+- `DetailPane` - Content display with syntax highlighting
+- `StatusPanel` - Shows current path and filter
+- `AppFooter` - Keyboard shortcuts
+
+### Mixins
+- `NavigationMixin` - Panel focus, cursor movement
+- `FilterMixin` - Level filters, search
+- `HelpMixin` - Help overlay
+
+## Testing
+
+```bash
+# Run all tests
+uv run pytest
+
+# Run with coverage
+uv run pytest --cov=lazyopencode
+
+# Run specific test file
+uv run pytest tests/unit/test_parsers.py
+```
+
+### Test Structure
+- `tests/unit/` - Unit tests for models, services, parsers
+- `tests/integration/` - App integration tests
+- `tests/conftest.py` - Shared fixtures
+
+## Dependencies
+
+### Runtime
+- `textual>=0.89.0` - TUI framework
+- `rich>=13.0.0` - Terminal formatting
+- `pyyaml>=6.0` - YAML/frontmatter parsing
+
+### Development
+- `pytest` - Testing
+- `pytest-asyncio` - Async test support
+- `ruff` - Linting and formatting
+
+## Adding New Features
+
+### Adding a new customization type
+1. Add enum value to `CustomizationType`
+2. Create parser in `services/parsers/`
+3. Register parser in `ConfigDiscoveryService`
+4. Add panel or tab in widgets
+
+### Adding a new keybinding
+1. Add binding to `bindings.py`
+2. Implement `action_*` method in appropriate mixin
+3. Update help text
+
+### Adding a new widget
+1. Create widget in `widgets/`
+2. Add styles to `styles/app.tcss`
+3. Compose in `app.py`
+
+## Planning Documents
+
+See `_plans/` directory for detailed specifications:
+- `00-overview.md` - Project overview
+- `01-architecture.md` - Architecture decisions
+- `02-customization-types.md` - OpenCode customization mapping
+- `03-implementation-phases.md` - Implementation plan
+- `04-file-structure.md` - File structure
+- `05-agents-md-template.md` - This template

lazyopencode-0.1.0/LICENSE

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