@dtt_siye/atool 1.1.0

package/skills/doc-standards-enforcer/scripts/fix_common_issues.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+"""
+Documentation Issues Auto-Fixer
+
+Automatically fixes common documentation standards issues.
+Interactive mode asks before applying each fix.
+
+Usage:
+    python fix_common_issues.py <file.md> --interactive
+    python fix_common_issues.py <file.md> --dry-run
+"""
+
+import sys
+import re
+from pathlib import Path
+from datetime import datetime
+import argparse
+
+
+class Colors:
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    RESET = '\033[0m'
+    BOLD = '\033[1m'
+
+
+class DocumentationFixer:
+    """Auto-fixes common documentation standards issues."""
+
+    REQUIRED_FIELDS = ['doc_id', 'title', 'status', 'owner', 'last_updated', 'related_docs']
+    VALID_STATUSES = ['draft', 'review', 'approved', 'deprecated']
+
+    def __init__(self, filepath, interactive=False, dry_run=False):
+        self.filepath = Path(filepath)
+        self.interactive = interactive
+        self.dry_run = dry_run
+        self.content = None
+        self.fixes_applied = []
+
+    def fix(self):
+        """Run auto-fixes."""
+        if not self.filepath.exists():
+            self.print_error(f"File not found: {self.filepath}")
+            return False
+
+        try:
+            self.content = self.filepath.read_text(encoding='utf-8')
+        except Exception as e:
+            self.print_error(f"Error reading file: {e}")
+            return False
+
+        print(f"\n{Colors.BOLD}Checking: {self.filepath.name}{Colors.RESET}\n")
+
+        # Run fix checks
+        self.fix_missing_frontmatter()
+        self.fix_missing_version_history()
+        self.suggest_filename_correction()
+        self.normalize_date_format()
+
+        # Apply fixes
+        if self.fixes_applied and not self.dry_run:
+            if self.confirm_apply():
+                self.filepath.write_text(self.content, encoding='utf-8')
+                self.print_success(f"\n✓ Applied {len(self.fixes_applied)} fix(es) to {self.filepath.name}")
+                return True
+        elif self.dry_run and self.fixes_applied:
+            self.print_info(f"\n[Dry run] Would apply {len(self.fixes_applied)} fix(es)")
+
+        if not self.fixes_applied:
+            self.print_info("No issues found that can be auto-fixed")
+
+        return True
+
+    def fix_missing_frontmatter(self):
+        """Add missing frontmatter template."""
+        # Check if frontmatter exists
+        frontmatter_match = re.match(r'^---\n(.*?)\n---', self.content, re.DOTALL)
+
+        if not frontmatter_match:
+            # No frontmatter - add template
+            template = self.get_frontmatter_template()
+
+            if self.confirm_fix("Add missing frontmatter template"):
+                self.content = template + "\n\n" + self.content
+                self.fixes_applied.append("Added frontmatter template")
+
+        else:
+            # Frontmatter exists - check for missing fields
+            frontmatter_text = frontmatter_match.group(1)
+            frontmatter_dict = {}
+
+            for line in frontmatter_text.split('\n'):
+                if ':' in line and not line.strip().startswith('#'):
+                    key, value = line.split(':', 1)
+                    frontmatter_dict[key.strip()] = value.strip()
+
+            missing_fields = [f for f in self.REQUIRED_FIELDS if f not in frontmatter_dict]
+
+            if missing_fields:
+                print(f"{Colors.YELLOW}Missing frontmatter fields: {', '.join(missing_fields)}{Colors.RESET}")
+
+                if self.confirm_fix(f"Add missing fields: {', '.join(missing_fields)}"):
+                    # Insert missing fields
+                    new_frontmatter = self.update_frontmatter(frontmatter_dict, missing_fields)
+                    self.content = re.sub(
+                        r'^---\n.*?\n---',
+                        new_frontmatter,
+                        self.content,
+                        flags=re.DOTALL,
+                        count=1
+                    )
+                    self.fixes_applied.append(f"Added fields: {', '.join(missing_fields)}")
+
+    def fix_missing_version_history(self):
+        """Add version history table if missing."""
+        # Check if version history exists
+        content_lower = self.content.lower()
+        has_version = any(kw in content_lower for kw in ['version', 'history', '版本历史'])
+        has_table = '|' in self.content and '---' in self.content
+
+        if has_version and not has_table:
+            version_template = self.get_version_history_template()
+
+            if self.confirm_fix("Add version history table"):
+                # Append to end of content
+                self.content += "\n\n" + version_template
+                self.fixes_applied.append("Added version history table")
+
+    def suggest_filename_correction(self):
+        """Suggest filename correction if invalid."""
+        filename = self.filepath.name
+        pattern = r'^\d{3}-[a-z0-9-]+\.md$'
+
+        if not re.match(pattern, filename):
+            # Try to extract a doc_id from frontmatter
+            doc_id = None
+            frontmatter_match = re.match(r'^---\n(.*?)\n---', self.content, re.DOTALL)
+
+            if frontmatter_match:
+                for line in frontmatter_match.group(1).split('\n'):
+                    if line.strip().startswith('doc_id:'):
+                        doc_id = line.split(':', 1)[1].strip()
+                        break
+
+            if doc_id:
+                # Extract 3-digit ID from doc_id
+                id_match = re.search(r'(\d{3})', doc_id)
+                if id_match:
+                    prefix = id_match.group(1)
+                    suggested_name = f"{prefix}-document.md"
+                    print(f"{Colors.CYAN}Suggested filename: {suggested_name}{Colors.RESET}")
+                    print(f"  {Colors.YELLOW}Run: mv '{filename}' '{suggested_name}'{Colors.RESET}")
+                    self.fixes_applied.append("Filename suggested (manual rename required)")
+
+    def normalize_date_format(self):
+        """Normalize date formats to YYYY-MM-DD."""
+        frontmatter_match = re.match(r'^---\n(.*?)\n---', self.content, re.DOTALL)
+
+        if frontmatter_match:
+            frontmatter_text = frontmatter_match.group(1)
+            modified = False
+
+            lines = frontmatter_text.split('\n')
+            new_lines = []
+
+            for line in lines:
+                if line.strip().startswith('last_updated:'):
+                    date_str = line.split(':', 1)[1].strip()
+
+                    # Try to parse and reformat
+                    try:
+                        # Try common formats
+                        for fmt in ['%Y-%m-%d', '%Y/%m/%d', '%Y.%m.%d', '%d-%m-%Y']:
+                            try:
+                                parsed = datetime.strptime(date_str, fmt)
+                                normalized = parsed.strftime('%Y-%m-%d')
+                                if date_str != normalized:
+                                    if self.confirm_fix(f"Normalize date '{date_str}' to '{normalized}'"):
+                                        new_lines.append(f"last_updated: {normalized}")
+                                        modified = True
+                                        self.fixes_applied.append(f"Normalized date format")
+                                        continue
+                                break
+                            except ValueError:
+                                continue
+                    except:
+                        pass
+
+                new_lines.append(line)
+
+            if modified:
+                new_frontmatter = '---\n' + '\n'.join(new_lines) + '\n---'
+                self.content = re.sub(
+                    r'^---\n.*?\n---',
+                    new_frontmatter,
+                    self.content,
+                    flags=re.DOTALL,
+                    count=1
+                )
+
+    def get_frontmatter_template(self):
+        """Generate frontmatter template."""
+        return f"""---
+doc_id: XXX-XXX-0100
+title: Document Title
+status: draft
+owner: Your Name
+last_updated: {datetime.now().strftime('%Y-%m-%d')}
+related_docs:
+  - docs/100-standards/101-documentation-standards.md
+---"""
+
+    def get_version_history_template(self):
+        """Generate version history table."""
+        return """## Version History
+
+| Version | Date | Owner | Change |
+|---|---|---|---|
+| v0.1 | {date} | Your Name | Initial version |
+""".format(date=datetime.now().strftime('%Y-%m-%d'))
+
+    def update_frontmatter(self, existing_dict, missing_fields):
+        """Update frontmatter with missing fields."""
+        # Add missing fields with placeholder values
+        for field in missing_fields:
+            if field == 'doc_id':
+                existing_dict[field] = 'XXX-XXX-0100'
+            elif field == 'title':
+                existing_dict[field] = 'Document Title'
+            elif field == 'status':
+                existing_dict[field] = 'draft'
+            elif field == 'owner':
+                existing_dict[field] = 'Your Name'
+            elif field == 'last_updated':
+                existing_dict[field] = datetime.now().strftime('%Y-%m-%d')
+            elif field == 'related_docs':
+                existing_dict[field] = '[]'
+
+        # Rebuild frontmatter string
+        lines = ['---']
+        for key, value in existing_dict.items():
+            lines.append(f'{key}: {value}')
+        lines.append('---')
+
+        return '\n'.join(lines)
+
+    def confirm_fix(self, message):
+        """Ask user to confirm fix."""
+        if not self.interactive and not self.dry_run:
+            return True
+
+        if self.dry_run:
+            print(f"  {Colors.CYAN}[Would fix] {message}{Colors.RESET}")
+            return False
+
+        response = input(f"  {Colors.YELLOW}Fix: {message}? [Y/n]{Colors.RESET} ").strip().lower()
+        return response in ['', 'y', 'yes']
+
+    def confirm_apply(self):
+        """Ask user to confirm applying all fixes."""
+        if not self.interactive:
+            return True
+
+        print(f"\n{Colors.GREEN}Fixes to apply ({len(self.fixes_applied)}):{Colors.RESET}")
+        for i, fix in enumerate(self.fixes_applied, 1):
+            print(f"  {i}. {fix}")
+
+        response = input(f"\n{Colors.BOLD}Apply these fixes? [Y/n]{Colors.RESET} ").strip().lower()
+        return response in ['', 'y', 'yes']
+
+    def print_error(self, message):
+        print(f"{Colors.RED}{message}{Colors.RESET}")
+
+    def print_info(self, message):
+        print(f"{Colors.BLUE}{message}{Colors.RESET}")
+
+    def print_success(self, message):
+        print(f"{Colors.GREEN}{message}{Colors.RESET}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Auto-fix common documentation issues'
+    )
+    parser.add_argument('file', help='Markdown file to fix')
+    parser.add_argument('-i', '--interactive', action='store_true',
+                       help='Interactive mode - ask before each fix')
+    parser.add_argument('-d', '--dry-run', action='store_true',
+                       help='Dry run - show what would be fixed without applying')
+
+    args = parser.parse_args()
+
+    fixer = DocumentationFixer(args.file, interactive=args.interactive, dry_run=args.dry_run)
+    success = fixer.fix()
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == '__main__':
+    main()

package/skills/doc-standards-enforcer/scripts/validate_doc_standards.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""
+Documentation Standards Validator
+
+Validates Markdown documents against the Inspection Agent project's
+documentation standards defined in 100-standards/101-documentation-standards.md.
+
+Usage:
+    python validate_doc_standards.py <file.md>
+    python validate_doc_standards.py <file.md> --verbose
+
+Exit codes:
+    0: All checks pass
+    1: Validation fails
+    2: File not found or other error
+"""
+
+import sys
+import re
+import os
+from pathlib import Path
+from datetime import datetime
+import argparse
+
+# ANSI color codes for terminal output
+class Colors:
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    RESET = '\033[0m'
+    BOLD = '\033[1m'
+
+
+class DocumentationValidator:
+    """Validates documentation standards compliance."""
+
+    # Required frontmatter fields
+    REQUIRED_FIELDS = ['doc_id', 'title', 'status', 'owner', 'last_updated', 'related_docs']
+
+    # Valid status values
+    VALID_STATUSES = ['draft', 'review', 'approved', 'deprecated']
+
+    # Required section keywords (can be English or Chinese)
+    REQUIRED_SECTIONS = [
+        'purpose', 'scope', '目的', '范围',  # Purpose/Scope
+        'content', '主体内容',  # Main Content
+        'version', 'history', '版本历史'  # Version History
+    ]
+
+    def __init__(self, filepath, verbose=False):
+        self.filepath = Path(filepath)
+        self.verbose = verbose
+        self.errors = []
+        self.warnings = []
+        self.content = None
+        self.frontmatter = {}
+
+    def validate(self):
+        """Run all validation checks."""
+        if not self.filepath.exists():
+            self.print_error(f"File not found: {self.filepath}")
+            return False
+
+        try:
+            self.content = self.filepath.read_text(encoding='utf-8')
+        except Exception as e:
+            self.print_error(f"Error reading file: {e}")
+            return False
+
+        # Run all validation checks
+        self.check_file_naming()
+        self.check_directory_structure()
+        self.check_frontmatter()
+        self.check_required_sections()
+        self.check_version_history()
+
+        # Print results
+        self.print_results()
+
+        return len(self.errors) == 0
+
+    def check_file_naming(self):
+        """Check if filename follows <3-digit-id>-<slug>.md pattern."""
+        filename = self.filepath.name
+
+        # Pattern: <3-digit-id>-<slug>.md
+        # Example: 201-project-brief.md
+        pattern = r'^\d{3}-[a-z0-9-]+\.md$'
+
+        if not re.match(pattern, filename):
+            self.errors.append({
+                'check': 'FILE_NAMING',
+                'message': f"File '{filename}' doesn't match pattern <3-digit-id>-<slug>.md",
+                'example': 'Example: 201-project-brief.md'
+            })
+
+        # Check for lowercase kebab-case
+        if filename != filename.lower():
+            self.errors.append({
+                'check': 'FILE_NAMING',
+                'message': f"File '{filename}' must be lowercase",
+                'fix': 'Convert to lowercase kebab-case'
+            })
+
+        # Check for Chinese characters in filename
+        if any('\u4e00' <= c <= '\u9fff' for c in filename):
+            self.errors.append({
+                'check': 'FILE_NAMING',
+                'message': f"File '{filename}' contains Chinese characters",
+                'fix': 'Use only ASCII characters (lowercase, digits, hyphens)'
+            })
+
+    def check_directory_structure(self):
+        """Check if directory follows hundreds-based pattern."""
+        parent_dir = self.filepath.parent.name
+
+        # Pattern: <hundreds>-<slug>
+        # Example: 100-standards, 200-product
+        pattern = r'^\d{3}-[a-z0-9-]+$'
+
+        if not re.match(pattern, parent_dir):
+            self.errors.append({
+                'check': 'DIRECTORY_STRUCTURE',
+                'message': f"Directory '{parent_dir}' doesn't match pattern <hundreds>-<slug>",
+                'example': 'Example: 100-standards, 200-product'
+            })
+
+        # Check if file ID matches directory hundreds
+        filename_id = self.filepath.name[:3] if len(self.filepath.name) >= 3 else ''
+        directory_hundreds = parent_dir[:3] if len(parent_dir) >= 3 else ''
+
+        if filename_id and directory_hundreds:
+            if filename_id[0] != directory_hundreds[0]:
+                self.warnings.append({
+                    'check': 'DIRECTORY_STRUCTURE',
+                    'message': f"File ID '{filename_id}' doesn't match directory hundreds '{directory_hundreds}'"
+                })
+
+    def check_frontmatter(self):
+        """Check frontmatter completeness and validity."""
+        # Extract frontmatter (YAML between --- markers)
+        frontmatter_match = re.match(r'^---\n(.*?)\n---', self.content, re.DOTALL)
+
+        if not frontmatter_match:
+            self.errors.append({
+                'check': 'FRONTMATTER',
+                'message': 'No frontmatter found',
+                'fix': 'Add YAML frontmatter between --- markers'
+            })
+            return
+
+        # Parse frontmatter
+        frontmatter_text = frontmatter_match.group(1)
+        for line in frontmatter_text.split('\n'):
+            if ':' in line and not line.strip().startswith('#'):
+                key, value = line.split(':', 1)
+                self.frontmatter[key.strip()] = value.strip()
+
+        if self.verbose:
+            self.print_info(f"Found frontmatter with {len(self.frontmatter)} fields")
+
+        # Check required fields
+        for field in self.REQUIRED_FIELDS:
+            if field not in self.frontmatter:
+                self.errors.append({
+                    'check': 'FRONTMATTER',
+                    'message': f"Missing required field: {field}",
+                    'required_fields': ', '.join(self.REQUIRED_FIELDS)
+                })
+
+        # Check status validity
+        if 'status' in self.frontmatter:
+            status = self.frontmatter['status'].strip()
+            if status not in self.VALID_STATUSES:
+                self.errors.append({
+                    'check': 'STATUS',
+                    'message': f"Invalid status '{status}'",
+                    'valid_values': ', '.join(self.VALID_STATUSES)
+                })
+
+        # Check date format
+        if 'last_updated' in self.frontmatter:
+            date_str = self.frontmatter['last_updated'].strip()
+            try:
+                datetime.strptime(date_str, '%Y-%m-%d')
+            except ValueError:
+                self.errors.append({
+                    'check': 'DATE_FORMAT',
+                    'message': f"Invalid date format '{date_str}'",
+                    'expected': 'YYYY-MM-DD'
+                })
+
+        # Check related_docs format
+        if 'related_docs' in self.frontmatter:
+            related = self.frontmatter['related_docs']
+            if related == '[]' or related == '':
+                self.warnings.append({
+                    'check': 'FRONTMATTER',
+                    'message': 'related_docs is empty'
+                })
+
+    def check_required_sections(self):
+        """Check for required document sections."""
+        content_lower = self.content.lower()
+
+        found_sections = []
+        for section_keyword in self.REQUIRED_SECTIONS:
+            if section_keyword in content_lower:
+                found_sections.append(section_keyword)
+
+        # Check if we have at least one from each category
+        has_purpose_scope = any(kw in content_lower for kw in ['purpose', 'scope', '目的', '范围'])
+        has_content = any(kw in content_lower for kw in ['content', '主体内容'])
+        has_version = any(kw in content_lower for kw in ['version', 'history', '版本历史'])
+
+        if not has_purpose_scope:
+            self.errors.append({
+                'check': 'REQUIRED_SECTIONS',
+                'message': 'Missing Purpose/Scope section',
+                'expected': 'Add section: ## Purpose (目的/范围)'
+            })
+
+        if not has_content:
+            self.warnings.append({
+                'check': 'REQUIRED_SECTIONS',
+                'message': 'Missing main content section'
+            })
+
+        if not has_version:
+            self.errors.append({
+                'check': 'REQUIRED_SECTIONS',
+                'message': 'Missing Version History section',
+                'expected': 'Add section: ## Version History (版本历史)'
+            })
+
+    def check_version_history(self):
+        """Check for version history table."""
+        # Look for markdown table with version, date, owner, change columns
+        content_lower = self.content.lower()
+
+        # Check for table markers
+        has_table = '|' in self.content and '---' in self.content
+
+        # Check for version history keywords
+        has_version_section = any(kw in content_lower for kw in ['version', 'history', '版本历史'])
+
+        if has_version_section and has_table:
+            # Check for required columns
+            table_content = self.content.lower()
+            required_columns = ['version', 'date']
+            missing_columns = [col for col in required_columns if col not in table_content]
+
+            if missing_columns:
+                self.warnings.append({
+                    'check': 'VERSION_HISTORY',
+                    'message': f"Version history table may be missing columns: {', '.join(missing_columns)}",
+                    'expected': 'Table should have: Version | Date | Owner | Change'
+                })
+        elif has_version_section:
+            self.errors.append({
+                'check': 'VERSION_HISTORY',
+                'message': 'Version History section exists but no table found',
+                'expected': 'Add version history table with columns: Version | Date | Owner | Change'
+            })
+
+    def print_results(self):
+        """Print validation results."""
+        if not self.errors and not self.warnings:
+            self.print_success(f"✓ All checks passed: {self.filepath}")
+        else:
+            self.print_error(f"✗ Validation failed: {self.filepath}")
+
+            # Print errors
+            for error in self.errors:
+                check = error['check']
+                message = error['message']
+                print(f"\n{Colors.RED}[ERROR] [{check}]{Colors.RESET} {message}")
+
+                if 'example' in error:
+                    print(f"  {Colors.BLUE}Example:{Colors.RESET} {error['example']}")
+                if 'fix' in error:
+                    print(f"  {Colors.BLUE}Fix:{Colors.RESET} {error['fix']}")
+                if 'expected' in error:
+                    print(f"  {Colors.BLUE}Expected:{Colors.RESET} {error['expected']}")
+                if 'valid_values' in error:
+                    print(f"  {Colors.BLUE}Valid values:{Colors.RESET} {error['valid_values']}")
+
+            # Print warnings
+            for warning in self.warnings:
+                check = warning['check']
+                message = warning['message']
+                print(f"\n{Colors.YELLOW}[WARNING] [{check}]{Colors.RESET} {message}")
+
+        # Summary
+        if self.errors:
+            print(f"\n{Colors.RED}{Colors.BOLD}Errors: {len(self.errors)}{Colors.RESET}")
+        if self.warnings:
+            print(f"{Colors.YELLOW}Warnings: {len(self.warnings)}{Colors.RESET}")
+
+    def print_error(self, message):
+        print(f"{Colors.RED}{message}{Colors.RESET}")
+
+    def print_warning(self, message):
+        print(f"{Colors.YELLOW}{message}{Colors.RESET}")
+
+    def print_success(self, message):
+        print(f"{Colors.GREEN}{message}{Colors.RESET}")
+
+    def print_info(self, message):
+        if self.verbose:
+            print(f"{Colors.BLUE}{message}{Colors.RESET}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Validate documentation against project standards'
+    )
+    parser.add_argument('file', help='Markdown file to validate')
+    parser.add_argument('-v', '--verbose', action='store_true',
+                       help='Enable verbose output')
+
+    args = parser.parse_args()
+
+    validator = DocumentationValidator(args.file, verbose=args.verbose)
+    valid = validator.validate()
+
+    sys.exit(0 if valid else 1)
+
+
+if __name__ == '__main__':
+    main()

package/skills/docx/LICENSE.txt

@@ -0,0 +1,30 @@
+© 2025 Anthropic, PBC. All rights reserved.
+
+LICENSE: Use of these materials (including all code, prompts, assets, files,
+and other components of this Skill) is governed by your agreement with
+Anthropic regarding use of Anthropic's services. If no separate agreement
+exists, use is governed by Anthropic's Consumer Terms of Service or
+Commercial Terms of Service, as applicable:
+https://www.anthropic.com/legal/consumer-terms
+https://www.anthropic.com/legal/commercial-terms
+Your applicable agreement is referred to as the "Agreement." "Services" are
+as defined in the Agreement.
+
+ADDITIONAL RESTRICTIONS: Notwithstanding anything in the Agreement to the
+contrary, users may not:
+
+- Extract these materials from the Services or retain copies of these
+  materials outside the Services
+- Reproduce or copy these materials, except for temporary copies created
+  automatically during authorized use of the Services
+- Create derivative works based on these materials
+- Distribute, sublicense, or transfer these materials to any third party
+- Make, offer to sell, sell, or import any inventions embodied in these
+  materials
+- Reverse engineer, decompile, or disassemble these materials
+
+The receipt, viewing, or possession of these materials does not convey or
+imply any license or right beyond those expressly granted above.
+
+Anthropic retains all right, title, and interest in these materials,
+including all copyrights, patents, and other intellectual property rights.