natureco-cli 5.18.2 → 5.19.0

package/skills/opensource-guide-coach/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: opensource-guide-coach
+description: Use when a user wants guidance on starting, contributing to, growing, governing, funding, securing, or sustaining an open source project, or asks about contributor onboarding, community health, maintainer burnout, code of conduct, metrics, legal basics, or open source project adoption.
+---
+
+## Overview
+
+Use the official Open Source Guides as a coaching framework for open source questions.
+
+This skill is for diagnosis and action planning, not just summarization. Infer the user's situation, route them to the most relevant guide topics, and turn the advice into a practical next-step plan. Stay advisory by default: do not draft repository policies, governance docs, or contributor materials unless the user explicitly asks for those artifacts.
+
+## Source Of Truth
+
+- Use the official Open Source Guides site: <https://opensource.guide/>
+- Use [`references/guide-map.md`](./references/guide-map.md) to select the right topic quickly
+- Use [`references/persona-router.md`](./references/persona-router.md) to infer the closest audience persona
+- Use [`references/attribution.md`](./references/attribution.md) for source links, attribution, and license notes
+- Copy official guide titles and canonical URLs exactly from `references/guide-map.md`
+
+Treat the guides as curated community practice, not binding policy. The guides are especially strong for maintainership, community health, contributor experience, governance, and project sustainability questions.
+
+## When To Use
+
+Use this skill when the user is trying to:
+
+- decide whether or how to open source a project
+- attract users or contributors
+- improve onboarding or contribution flow
+- reduce maintainer overload or burnout
+- set governance or decision-making expectations
+- adopt or enforce a code of conduct
+- choose useful project metrics
+- think about funding or sustainability
+- understand open source legal basics
+- tighten project security practices
+
+Do not use this skill for:
+
+- GitHub product how-to questions that need product docs
+- repository-specific legal advice that requires a lawyer
+- deep software security implementation guidance unrelated to open source project operations
+
+## Working Style
+
+### 1. Identify the situation
+
+Infer:
+
+- the closest persona
+- the project stage: considering launch, early launch, growing, overwhelmed, or formalizing
+- the main pain point
+- whether the user wants advice, a checklist, or actual drafted artifacts
+
+If details are missing, make a reasonable inference and state it briefly. Do not interrogate the user for every unknown if a safe assumption will do.
+
+### 2. Choose the smallest useful guide set
+
+Pick `1-3` guide topics.
+
+- Use `1` guide for narrow questions
+- Use `2` guides for common combined situations
+- Use `3` guides only when the request clearly spans multiple concerns
+
+Do not dump the entire guide catalog on the user.
+
+### 3. Convert guidance into action
+
+Translate the guide themes into a prioritized plan that fits the user's scale.
+
+- Prefer the next `3-6` concrete actions
+- Match the level of process to the maturity of the project
+- Avoid recommending heavyweight governance or documentation too early
+- Keep the plan practical for solo maintainers and volunteer projects
+
+### 4. Link back to the official source
+
+For each recommended guide, include the official `opensource.guide` URL and one short sentence on why it applies.
+
+- Use the canonical URL from `references/guide-map.md`
+- Do not shorten, guess, or rewrite article slugs
+- Use the official article title exactly as written in `references/guide-map.md`
+
+### 5. Stay advisory by default
+
+Unless the user explicitly asks for drafting help:
+
+- do not write a full `CONTRIBUTING.md`
+- do not write a governance charter
+- do not write a code of conduct
+- do not generate a full legal policy
+
+If the user does ask for an artifact, say which guide(s) you are basing it on and then draft only the requested artifact.
+
+## Routing Heuristics
+
+Reach for these patterns first:
+
+- Launch decision, project scope, expectations, readiness: `starting-a-project`
+- How newcomers can help, contribution flow, first PR path: `how-to-contribute`
+- Adoption, awareness, project discovery: `finding-users`
+- Welcoming environment, community participation, contributor experience: `building-community`
+- Maintainer workload, process clarity, saying no, automation: `best-practices`
+- Shared decision-making, leadership models, formal rules: `leadership-and-governance`
+- Sustainability, sponsorship, funding models: `getting-paid`
+- Behavior expectations and enforcement norms: `code-of-conduct`
+- Measuring health and progress: `metrics`
+- Licensing and legal basics: `legal`
+- Burnout, boundaries, maintainership balance: `maintaining-balance-for-open-source-maintainers`
+- Security hygiene, project trust, dependency and vulnerability practices: `security-best-practices-for-your-project`
+
+Common pairings:
+
+- First launch + adoption: `starting-a-project` + `finding-users`
+- Contributor growth + community experience: `how-to-contribute` + `building-community`
+- Maintainer overload + burnout: `best-practices` + `maintaining-balance-for-open-source-maintainers`
+- Governance + conduct expectations: `leadership-and-governance` + `code-of-conduct`
+- Trust + sustainability for mature projects: `security-best-practices-for-your-project` + `best-practices` or `getting-paid`
+
+Canonical title reminders:
+
+- `starting-a-project` -> `Starting an Open Source Project`
+- `code-of-conduct` -> `Your Code of Conduct`
+- `security-best-practices-for-your-project` -> `Security Best Practices for your Project`
+
+## Response Contract
+
+Always use this structure:
+
+Respond in plain Markdown only.
+
+- Do not emit pseudo-tool calls
+- Do not emit XML-like tags
+- Do not emit internal reasoning markers
+- Do not rename the section headings below
+- If you begin responding, complete all five sections
+- Never return empty wrappers, placeholders, or partial scaffolding
+
+## Situation
+
+State the inferred persona, project stage, and main challenge in plain language. If you made an assumption, note it in one sentence.
+
+## Relevant Guides
+
+List `1-3` guides. For each one include:
+
+- official title copied exactly from `references/guide-map.md`, including capitalization
+- why it applies here
+- official URL
+
+Preferred format:
+
+`**Official Title**`
+
+`Why it applies: ...`
+
+`URL: <https://opensource.guide/...>`
+
+## Recommended Next Steps
+
+Provide a prioritized numbered list. Keep it concrete and proportionate to the user's scale.
+
+## Watch-outs
+
+Call out risks, anti-patterns, or ways the user could over-process the problem.
+
+## Optional deeper reading
+
+Include any extra guide links only if they are genuinely useful. If not, say that the guides above are enough for now.
+
+Mini example:
+
+## Situation
+
+You are an early-stage solo maintainer deciding whether your side project is ready for open source.
+
+## Relevant Guides
+
+**Starting an Open Source Project**
+
+Why it applies: It helps you decide whether to launch now and what basics to prepare first.
+
+URL: <https://opensource.guide/starting-a-project/>
+
+## Recommended Next Steps
+
+1. Clarify the project scope and your maintenance boundaries.
+2. Add a license, README, and minimal contributor expectations.
+3. Share with a small early audience before a broader announcement.
+
+## Watch-outs
+
+Do not over-promise support or add heavyweight process before you need it.
+
+## Optional deeper reading
+
+If you want to think about early contributor experience, read How to Contribute to Open Source next.
+
+## Quality Bar
+
+Your answer should:
+
+- sound like coaching, not policy boilerplate
+- reflect the likely persona and maturity level
+- use official guide links, not third-party summaries
+- avoid presenting legal content as legal advice
+- avoid copying long passages from the source material
+- leave the user with a clear next move
+
+## Escalation Rules
+
+Escalate carefully when:
+
+- the user is asking for legal certainty rather than general guidance
+- the user needs incident response or code-level security help
+- the user wants formal governance that may be disproportionate for a tiny project
+- the user is clearly burned out and needs boundaries more than process
+
+In those cases, keep the recommendation practical and say what this skill can and cannot confidently cover.

package/skills/output-skill/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: full-output-enforcement
+description: Overrides default LLM truncation behavior. Enforces complete code generation, bans placeholder patterns, and handles token-limit splits cleanly. Apply to any task requiring exhaustive, unabridged output.
+---
+
+# Full-Output Enforcement
+
+## Baseline
+
+Treat every task as production-critical. A partial output is a broken output. Do not optimize for brevity — optimize for completeness. If the user asks for a full file, deliver the full file. If the user asks for 5 components, deliver 5 components. No exceptions.
+
+## Banned Output Patterns
+
+The following patterns are hard failures. Never produce them:
+
+**In code blocks:** `// ...`, `// rest of code`, `// implement here`, `// TODO`, `/* ... */`, `// similar to above`, `// continue pattern`, `// add more as needed`, bare `...` standing in for omitted code
+
+**In prose:** "Let me know if you want me to continue", "I can provide more details if needed", "for brevity", "the rest follows the same pattern", "similarly for the remaining", "and so on" (when replacing actual content), "I'll leave that as an exercise"
+
+**Structural shortcuts:** Outputting a skeleton when the request was for a full implementation. Showing the first and last section while skipping the middle. Replacing repeated logic with one example and a description. Describing what code should do instead of writing it.
+
+## Execution Process
+
+1. **Scope** — Read the full request. Count how many distinct deliverables are expected (files, functions, sections, answers). Lock that number.
+2. **Build** — Generate every deliverable completely. No partial drafts, no "you can extend this later."
+3. **Cross-check** — Before output, re-read the original request. Compare your deliverable count against the scope count. If anything is missing, add it before responding.
+
+## Handling Long Outputs
+
+When a response approaches the token limit:
+
+- Do not compress remaining sections to squeeze them in.
+- Do not skip ahead to a conclusion.
+- Write at full quality up to a clean breakpoint (end of a function, end of a file, end of a section).
+- End with:
+
+```
+[PAUSED — X of Y complete. Send "continue" to resume from: next section name]
+```
+
+On "continue", pick up exactly where you stopped. No recap, no repetition.
+
+## Quick Check
+
+Before finalizing any response, verify:
+- No banned patterns from the list above appear anywhere in the output
+- Every item the user requested is present and finished
+- Code blocks contain actual runnable code, not descriptions of what code would do
+- Nothing was shortened to save space

package/skills/pdf/SKILL.md

@@ -0,0 +1,314 @@
+---
+name: pdf
+description: Use this skill whenever the user wants to do anything with PDF files. This includes reading or extracting text/tables from PDFs, combining or merging multiple PDFs into one, splitting PDFs apart, rotating pages, adding watermarks, creating new PDFs, filling PDF forms, encrypting/decrypting PDFs, extracting images, and OCR on scanned PDFs to make them searchable. If the user mentions a .pdf file or asks to produce one, use this skill.
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# PDF Processing Guide
+
+## Overview
+
+This guide covers essential PDF processing operations using Python libraries and command-line tools. For advanced features, JavaScript libraries, and detailed examples, see REFERENCE.md. If you need to fill out a PDF form, read FORMS.md and follow its instructions.
+
+## Quick Start
+
+```python
+from pypdf import PdfReader, PdfWriter
+
+# Read a PDF
+reader = PdfReader("document.pdf")
+print(f"Pages: {len(reader.pages)}")
+
+# Extract text
+text = ""
+for page in reader.pages:
+    text += page.extract_text()
+```
+
+## Python Libraries
+
+### pypdf - Basic Operations
+
+#### Merge PDFs
+```python
+from pypdf import PdfWriter, PdfReader
+
+writer = PdfWriter()
+for pdf_file in ["doc1.pdf", "doc2.pdf", "doc3.pdf"]:
+    reader = PdfReader(pdf_file)
+    for page in reader.pages:
+        writer.add_page(page)
+
+with open("merged.pdf", "wb") as output:
+    writer.write(output)
+```
+
+#### Split PDF
+```python
+reader = PdfReader("input.pdf")
+for i, page in enumerate(reader.pages):
+    writer = PdfWriter()
+    writer.add_page(page)
+    with open(f"page_{i+1}.pdf", "wb") as output:
+        writer.write(output)
+```
+
+#### Extract Metadata
+```python
+reader = PdfReader("document.pdf")
+meta = reader.metadata
+print(f"Title: {meta.title}")
+print(f"Author: {meta.author}")
+print(f"Subject: {meta.subject}")
+print(f"Creator: {meta.creator}")
+```
+
+#### Rotate Pages
+```python
+reader = PdfReader("input.pdf")
+writer = PdfWriter()
+
+page = reader.pages[0]
+page.rotate(90)  # Rotate 90 degrees clockwise
+writer.add_page(page)
+
+with open("rotated.pdf", "wb") as output:
+    writer.write(output)
+```
+
+### pdfplumber - Text and Table Extraction
+
+#### Extract Text with Layout
+```python
+import pdfplumber
+
+with pdfplumber.open("document.pdf") as pdf:
+    for page in pdf.pages:
+        text = page.extract_text()
+        print(text)
+```
+
+#### Extract Tables
+```python
+with pdfplumber.open("document.pdf") as pdf:
+    for i, page in enumerate(pdf.pages):
+        tables = page.extract_tables()
+        for j, table in enumerate(tables):
+            print(f"Table {j+1} on page {i+1}:")
+            for row in table:
+                print(row)
+```
+
+#### Advanced Table Extraction
+```python
+import pandas as pd
+
+with pdfplumber.open("document.pdf") as pdf:
+    all_tables = []
+    for page in pdf.pages:
+        tables = page.extract_tables()
+        for table in tables:
+            if table:  # Check if table is not empty
+                df = pd.DataFrame(table[1:], columns=table[0])
+                all_tables.append(df)
+
+# Combine all tables
+if all_tables:
+    combined_df = pd.concat(all_tables, ignore_index=True)
+    combined_df.to_excel("extracted_tables.xlsx", index=False)
+```
+
+### reportlab - Create PDFs
+
+#### Basic PDF Creation
+```python
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+
+c = canvas.Canvas("hello.pdf", pagesize=letter)
+width, height = letter
+
+# Add text
+c.drawString(100, height - 100, "Hello World!")
+c.drawString(100, height - 120, "This is a PDF created with reportlab")
+
+# Add a line
+c.line(100, height - 140, 400, height - 140)
+
+# Save
+c.save()
+```
+
+#### Create PDF with Multiple Pages
+```python
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet
+
+doc = SimpleDocTemplate("report.pdf", pagesize=letter)
+styles = getSampleStyleSheet()
+story = []
+
+# Add content
+title = Paragraph("Report Title", styles['Title'])
+story.append(title)
+story.append(Spacer(1, 12))
+
+body = Paragraph("This is the body of the report. " * 20, styles['Normal'])
+story.append(body)
+story.append(PageBreak())
+
+# Page 2
+story.append(Paragraph("Page 2", styles['Heading1']))
+story.append(Paragraph("Content for page 2", styles['Normal']))
+
+# Build PDF
+doc.build(story)
+```
+
+#### Subscripts and Superscripts
+
+**IMPORTANT**: Never use Unicode subscript/superscript characters (₀₁₂₃₄₅₆₇₈₉, ⁰¹²³⁴⁵⁶⁷⁸⁹) in ReportLab PDFs. The built-in fonts do not include these glyphs, causing them to render as solid black boxes.
+
+Instead, use ReportLab's XML markup tags in Paragraph objects:
+```python
+from reportlab.platypus import Paragraph
+from reportlab.lib.styles import getSampleStyleSheet
+
+styles = getSampleStyleSheet()
+
+# Subscripts: use <sub> tag
+chemical = Paragraph("H<sub>2</sub>O", styles['Normal'])
+
+# Superscripts: use <super> tag
+squared = Paragraph("x<super>2</super> + y<super>2</super>", styles['Normal'])
+```
+
+For canvas-drawn text (not Paragraph objects), manually adjust font the size and position rather than using Unicode subscripts/superscripts.
+
+## Command-Line Tools
+
+### pdftotext (poppler-utils)
+```bash
+# Extract text
+pdftotext input.pdf output.txt
+
+# Extract text preserving layout
+pdftotext -layout input.pdf output.txt
+
+# Extract specific pages
+pdftotext -f 1 -l 5 input.pdf output.txt  # Pages 1-5
+```
+
+### qpdf
+```bash
+# Merge PDFs
+qpdf --empty --pages file1.pdf file2.pdf -- merged.pdf
+
+# Split pages
+qpdf input.pdf --pages . 1-5 -- pages1-5.pdf
+qpdf input.pdf --pages . 6-10 -- pages6-10.pdf
+
+# Rotate pages
+qpdf input.pdf output.pdf --rotate=+90:1  # Rotate page 1 by 90 degrees
+
+# Remove password
+qpdf --password=mypassword --decrypt encrypted.pdf decrypted.pdf
+```
+
+### pdftk (if available)
+```bash
+# Merge
+pdftk file1.pdf file2.pdf cat output merged.pdf
+
+# Split
+pdftk input.pdf burst
+
+# Rotate
+pdftk input.pdf rotate 1east output rotated.pdf
+```
+
+## Common Tasks
+
+### Extract Text from Scanned PDFs
+```python
+# Requires: pip install pytesseract pdf2image
+import pytesseract
+from pdf2image import convert_from_path
+
+# Convert PDF to images
+images = convert_from_path('scanned.pdf')
+
+# OCR each page
+text = ""
+for i, image in enumerate(images):
+    text += f"Page {i+1}:\n"
+    text += pytesseract.image_to_string(image)
+    text += "\n\n"
+
+print(text)
+```
+
+### Add Watermark
+```python
+from pypdf import PdfReader, PdfWriter
+
+# Create watermark (or load existing)
+watermark = PdfReader("watermark.pdf").pages[0]
+
+# Apply to all pages
+reader = PdfReader("document.pdf")
+writer = PdfWriter()
+
+for page in reader.pages:
+    page.merge_page(watermark)
+    writer.add_page(page)
+
+with open("watermarked.pdf", "wb") as output:
+    writer.write(output)
+```
+
+### Extract Images
+```bash
+# Using pdfimages (poppler-utils)
+pdfimages -j input.pdf output_prefix
+
+# This extracts all images as output_prefix-000.jpg, output_prefix-001.jpg, etc.
+```
+
+### Password Protection
+```python
+from pypdf import PdfReader, PdfWriter
+
+reader = PdfReader("input.pdf")
+writer = PdfWriter()
+
+for page in reader.pages:
+    writer.add_page(page)
+
+# Add password
+writer.encrypt("userpassword", "ownerpassword")
+
+with open("encrypted.pdf", "wb") as output:
+    writer.write(output)
+```
+
+## Quick Reference
+
+| Task | Best Tool | Command/Code |
+|------|-----------|--------------|
+| Merge PDFs | pypdf | `writer.add_page(page)` |
+| Split PDFs | pypdf | One page per file |
+| Extract text | pdfplumber | `page.extract_text()` |
+| Extract tables | pdfplumber | `page.extract_tables()` |
+| Create PDFs | reportlab | Canvas or Platypus |
+| Command line merge | qpdf | `qpdf --empty --pages ...` |
+| OCR scanned PDFs | pytesseract | Convert to image first |
+| Fill PDF forms | pdf-lib or pypdf (see FORMS.md) | See FORMS.md |
+
+## Next Steps
+
+- For advanced pypdfium2 usage, see REFERENCE.md
+- For JavaScript libraries (pdf-lib), see REFERENCE.md
+- If you need to fill out a PDF form, follow the instructions in FORMS.md
+- For troubleshooting guides, see REFERENCE.md