ace-lint 0.25.0

data/handbook/skills/as-lint-fix-issue-from/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: as-lint-fix-issue-from
+description: Fix linting issues identified in ace-lint report output
+# bundle: wfi://lint/run
+# context: no-fork
+# agent: general-purpose
+user-invocable: true
+allowed-tools:
+  - Bash(ace-lint:*)
+  - Bash(ace-bundle:*)
+  - Bash(ace-git-commit:*)
+  - Read
+  - Write
+  - Edit
+  - Grep
+argument-hint: [linter-output-file]
+last_modified: 2026-01-10
+source: ace-lint
+integration:
+  targets:
+    - claude
+    - codex
+    - gemini
+    - opencode
+    - pi
+  providers: {}
+skill:
+  kind: workflow
+  execution:
+    workflow: wfi://lint/run
+---
+
+Load and run `ace-bundle wfi://lint/run` in the current project, then follow the loaded workflow as the source of truth and execute it end-to-end instead of only summarizing it.
+

data/handbook/skills/as-lint-process-report/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: as-lint-process-report
+description: Process lint report and create tasks for manual fixes
+# bundle: wfi://lint/process-report
+# context: no-fork
+# agent: general-purpose
+user-invocable: true
+allowed-tools:
+  - Bash(ace-lint:*)
+  - Bash(ace-bundle:*)
+  - Read
+argument-hint: [report-path]
+last_modified: 2026-03-10
+source: ace-lint
+integration:
+  targets:
+    - claude
+    - codex
+    - gemini
+    - opencode
+    - pi
+  providers: {}
+skill:
+  kind: workflow
+  execution:
+    workflow: wfi://lint/process-report
+---
+
+Load and run `ace-bundle wfi://lint/process-report` in the current project, then follow the loaded workflow as the source of truth and execute it end-to-end instead of only summarizing it.

data/handbook/skills/as-lint-run/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: as-lint-run
+description: Run ace-lint on project files with optional autofix and report
+# bundle: wfi://lint/run
+# agent: general-purpose
+user-invocable: true
+allowed-tools:
+  - Bash(ace-lint:*)
+  - Bash(ace-bundle:*)
+  - Read
+argument-hint: "[file-pattern] [--fix] [--report]"
+last_modified: 2026-03-10
+source: ace-lint
+integration:
+  targets:
+    - claude
+    - codex
+    - gemini
+    - opencode
+    - pi
+skill:
+  kind: workflow
+  execution:
+    workflow: wfi://lint/run
+---
+
+Load and run `ace-bundle wfi://lint/run` in the current project, then follow the loaded workflow as the source of truth and execute it end-to-end instead of only summarizing it.

data/handbook/workflow-instructions/lint/process-report.wf.md

@@ -0,0 +1,175 @@
+---
+doc-type: workflow
+title: Process Lint Report Workflow
+purpose: lint report processing workflow instruction
+ace-docs:
+  last-updated: 2026-03-06
+  last-checked: 2026-03-21
+---
+
+# Process Lint Report Workflow
+
+## Purpose
+
+Parse a lint report file and create structured tasks for issues requiring manual intervention. Groups issues by severity and type, generates fix proposals, and drafts tasks via ace-taskflow.
+
+## Prerequisites
+
+- Lint report file exists (from `wfi://lint/run --report`)
+- **ace-taskflow is installed and available** - required for task creation commands
+- Understanding of project lint rules
+
+## Variables
+
+- `$report_path`: Path to lint report JSON file (from argument)
+
+## Instructions
+
+1. **Locate and read the lint report**:
+
+   **If report path provided:**
+   ```bash
+   cat "$report_path"
+   ```
+
+   **If no path, find most recent:**
+   ```bash
+   ls -t .ace-lint/reports/*.json | head -1
+   ```
+
+2. **Parse and analyze errors**:
+   - Group by severity (error > warning)
+   - Group by file (for efficient fixing)
+   - Group by rule type (similar fixes together)
+
+3. **Generate fix proposals** for each issue:
+
+   | Rule Type | Fix Approach |
+   |-----------|--------------|
+   | frontmatter-required | Add missing field with default value |
+   | yaml-syntax | Suggest correct syntax structure |
+   | markdown-structure | Recommend structural changes |
+   | link-broken | Suggest path updates or removal |
+
+4. **Prioritize issues**:
+   - **P0 (blocking)**: Syntax errors preventing file parsing
+   - **P1 (high)**: Missing required metadata
+   - **P2 (medium)**: Style/formatting issues
+   - **P3 (low)**: Suggestions and improvements
+
+5. **Create tasks via ace-taskflow**:
+
+   **For grouped issues (multiple similar errors):**
+   ```bash
+   ace-idea create --llm-enhance "Fix [N] [rule-type] lint errors in [component]
+
+   Affected files:
+   - file1.md (line 10, 25)
+   - file2.md (line 5)
+
+   Fix approach: [common fix description]"
+   ```
+
+   **For complex single issues:**
+   ```bash
+   ace-idea create --llm-enhance "Fix [rule-type] in [file]
+
+   Error: [error message]
+   Location: [file:line]
+
+   Suggested fix: [fix proposal]"
+   ```
+
+6. **Generate summary report**:
+
+   ```markdown
+   # Lint Report Processing Summary
+
+   ## Report: [report_path]
+   ## Processed: [timestamp]
+
+   ### Issues by Priority
+
+   | Priority | Count | Status |
+   |----------|-------|--------|
+   | P0 | N | Task created |
+   | P1 | N | Task created |
+   | P2 | N | Grouped into M tasks |
+   | P3 | N | Logged for later |
+
+   ### Tasks Created
+
+   1. [Task ID]: [Title] - [N] issues
+   2. [Task ID]: [Title] - [N] issues
+
+   ### Issues Deferred (P3)
+
+   - [issue description] - [file:line]
+   ```
+
+## Grouping Strategy
+
+### Group by File (for small projects)
+- All issues in one file → single task
+- Efficient for focused fixes
+
+### Group by Rule Type (for large projects)
+- All `frontmatter-required` errors → one task
+- Efficient for batch fixes with similar patterns
+
+### Group by Component (for mono-repos)
+- All issues in `ace-lint/` → one task
+- Respects package boundaries
+
+## Fix Proposal Templates
+
+### Missing Frontmatter Field
+```markdown
+**Fix:** Add the following to YAML frontmatter:
+\`\`\`yaml
+doc-type: [suggested-type]
+\`\`\`
+```
+
+### YAML Syntax Error
+```markdown
+**Fix:** Correct YAML syntax at line [N]:
+- Issue: [description]
+- Current: `[problematic line]`
+- Suggested: `[corrected line]`
+```
+
+### Broken Link
+```markdown
+**Fix:** Update link reference:
+- Current: `[broken-path]`
+- Options:
+  1. Update to: `[correct-path]` (if file moved)
+  2. Remove link (if resource deleted)
+  3. Mark as external (if external URL)
+```
+
+## Success Criteria
+
+- Report successfully parsed
+- Issues grouped logically
+- Fix proposals generated for each issue
+- Tasks created in ace-taskflow
+- Summary report generated
+- No issues lost or duplicated
+
+## Response Template
+
+**Report Processed:** [report_path]
+**Total Issues:** [N]
+**Tasks Created:** [M]
+**Issues Grouped:** [breakdown by priority]
+**Next Steps:**
+- Run `/as-task-work [task-id]` for each created task
+- Re-run lint after fixes to verify
+
+## Error Handling
+
+- **Empty report**: Report success, no tasks needed
+- **Invalid JSON**: Report parse error, suggest re-running lint
+- **ace-taskflow unavailable**: Output task drafts as markdown

data/handbook/workflow-instructions/lint/run.wf.md

@@ -0,0 +1,145 @@
+---
+doc-type: workflow
+title: Run Lint Workflow
+purpose: lint workflow instruction
+ace-docs:
+  last-updated: 2026-02-23
+  last-checked: 2026-03-21
+---
+
+# Run Lint Workflow
+
+## Purpose
+
+Execute ace-lint on project files with intelligent file selection, optional autofix coordination, and structured report generation for AI-assisted code quality improvement.
+
+## Context
+
+ace-lint automatically:
+- Detects file types from extensions (.md, .yml, .yaml)
+- Validates markdown frontmatter and structure
+- Checks YAML syntax
+- Reports errors in structured format
+
+## Variables
+
+- `$file_pattern`: Optional glob pattern or file paths (from argument)
+- `$fix`: Whether to attempt autofixes (from --fix flag)
+- `$report`: Whether to generate JSON report (from --report flag)
+
+## Instructions
+
+1. **Review embedded repository status** in `<current_repository_status>`:
+   - Which files have been modified?
+   - What types of files are involved?
+   - Is this a targeted lint or full project scan?
+
+2. **Select files to lint** based on context:
+   - If file pattern provided: Use that pattern
+   - If recent changes: Focus on changed files
+   - Otherwise: Lint project-wide
+
+3. **Execute lint command**:
+
+   **Basic lint (all markdown/yaml):**
+   ```bash
+   ace-lint "**/*.md" "**/*.yml"
+   ```
+
+   **Lint specific files:**
+   ```bash
+   ace-lint path/to/file.md path/to/other.yml
+   ```
+
+   **Lint with glob pattern:**
+   ```bash
+   ace-lint "**/*.md"
+   ```
+
+   **Lint changed files only:**
+   ```bash
+   git diff --name-only --diff-filter=AM | grep -E '\.(md|ya?ml)$' | xargs ace-lint
+   ```
+
+4. **Handle results**:
+   - **Exit code 0**: All files pass - report success
+   - **Exit code 1**: Errors found - analyze and fix or generate report
+   - **Exit code 2**: Fatal error - investigate and report
+
+5. **If errors found and --fix requested**:
+   - Analyze each error type
+   - Apply safe autofixes where possible
+   - Re-run lint to verify fixes
+   - Report remaining manual-fix issues
+
+6. **If --report requested**, generate JSON report:
+   ```bash
+   # Create report directory if needed
+   mkdir -p .ace-lint/reports
+
+   # Generate timestamped report
+   REPORT_FILE=".ace-lint/reports/lint-$(date +%Y%m%d-%H%M%S).json"
+   ```
+
+   Report structure:
+   ```json
+   {
+     "timestamp": "2026-01-08T16:30:00Z",
+     "files_checked": 42,
+     "errors": [
+       {
+         "file": "path/to/file.md",
+         "line": 10,
+         "severity": "error",
+         "rule": "frontmatter-required",
+         "message": "Missing required frontmatter field: doc-type",
+         "fix_proposal": "Add 'doc-type: workflow' to frontmatter"
+       }
+     ],
+     "summary": {
+       "total_errors": 5,
+       "by_severity": {"error": 3, "warning": 2},
+       "by_rule": {"frontmatter-required": 2, "yaml-syntax": 3}
+     }
+   }
+   ```
+
+## Options Reference
+
+ace-lint CLI options:
+- `--quiet`: Suppress detailed output
+- `--version`: Show version
+- File types auto-detected from extensions
+
+## Common Error Patterns
+
+### Markdown Issues
+- Missing frontmatter → Add required YAML block
+- Invalid frontmatter syntax → Fix YAML structure
+- Broken internal links → Update path references
+
+### YAML Issues
+- Indentation errors → Fix spacing (2 spaces)
+- Missing quotes → Add quotes around special characters
+- Invalid syntax → Check colons, dashes, brackets
+
+### Frontmatter Issues
+- Missing required fields → Add doc-type, purpose, etc.
+- Invalid date format → Use YYYY-MM-DD
+- Type mismatches → Ensure correct value types
+
+## Success Criteria
+
+- All specified files linted
+- Errors clearly reported with file:line format
+- Autofixes applied safely (if requested)
+- JSON report generated (if requested)
+- Clear summary of remaining issues
+
+## Response Template
+
+**Files Linted:** [count] files
+**Result:** ✓ All pass | ✗ [N] errors found
+**Autofixes Applied:** [count] (if --fix)
+**Report Generated:** [path] (if --report)
+**Manual Fixes Needed:** [list of issues requiring human intervention]

data/lib/ace/lint/atoms/allowed_tools_validator.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Ace
+  module Lint
+    module Atoms
+      # Validates allowed-tools entries against known tools list
+      # Handles both simple tool names and Bash(prefix:*) patterns
+      class AllowedToolsValidator
+        # Pattern to match Bash(prefix:*) format
+        # e.g., "Bash(ace-git:*)", "Bash(npm:*)"
+        BASH_PATTERN_REGEX = /\ABash\(([^:]+):\*\)\z/
+
+        class << self
+          # Validate allowed-tools array
+          # @param tools [Array<String>, String] Tool entries to validate
+          # @param known_tools [Array<String>] List of known tool names
+          # @param known_bash_prefixes [Array<String>] List of known Bash command prefixes
+          # @return [Array<Hash>] List of validation errors with :tool and :message
+          def validate(tools, known_tools:, known_bash_prefixes:)
+            errors = []
+
+            # Handle string format (comma-separated)
+            tools_array = normalize_tools(tools)
+
+            tools_array.each do |tool|
+              tool = tool.to_s.strip
+              next if tool.empty?
+
+              error = validate_single_tool(tool, known_tools, known_bash_prefixes)
+              errors << error if error
+            end
+
+            errors
+          end
+
+          private
+
+          # Normalize tools to array format
+          # @param tools [Array, String, nil] Tools in various formats
+          # @return [Array<String>] Normalized array of tool names
+          def normalize_tools(tools)
+            case tools
+            when Array
+              tools.flatten
+            when String
+              # Handle comma-separated string format from workflow files
+              tools.split(",").map(&:strip)
+            when nil
+              []
+            else
+              [tools.to_s]
+            end
+          end
+
+          # Validate a single tool entry
+          # @param tool [String] Tool name or Bash pattern
+          # @param known_tools [Array<String>] Known tool names
+          # @param known_bash_prefixes [Array<String>] Known Bash prefixes
+          # @return [Hash, nil] Error hash or nil if valid
+          def validate_single_tool(tool, known_tools, known_bash_prefixes)
+            # Check for Bash(prefix:*) pattern
+            if (match = tool.match(BASH_PATTERN_REGEX))
+              prefix = match[1]
+              return validate_bash_prefix(prefix, known_bash_prefixes)
+            end
+
+            # Check for simple tool name
+            validate_tool_name(tool, known_tools)
+          end
+
+          # Validate a Bash prefix
+          # @param prefix [String] The Bash command prefix
+          # @param known_prefixes [Array<String>] Known prefixes
+          # @return [Hash, nil] Error hash or nil if valid
+          def validate_bash_prefix(prefix, known_prefixes)
+            return nil if known_prefixes.include?(prefix)
+
+            {
+              tool: "Bash(#{prefix}:*)",
+              message: "Unknown Bash prefix '#{prefix}'. Known prefixes: #{known_prefixes.first(5).join(", ")}... (#{known_prefixes.size} total)"
+            }
+          end
+
+          # Validate a simple tool name
+          # @param tool [String] Tool name
+          # @param known_tools [Array<String>] Known tools
+          # @return [Hash, nil] Error hash or nil if valid
+          def validate_tool_name(tool, known_tools)
+            return nil if known_tools.include?(tool)
+
+            {
+              tool: tool,
+              message: "Unknown tool '#{tool}'. Known tools: #{known_tools.first(5).join(", ")}... (#{known_tools.size} total)"
+            }
+          end
+        end
+      end
+    end
+  end
+end