support-to-repro-pack

Convert support tickets, logs, and screenshots into sanitized, reproducible engineering issue packs

Security Scan

The skill's code, CLI, and runtime instructions are broadly consistent with its stated purpose (turning tickets/logs/screenshots into sanitized reproducible issue packs), with only minor implementation/clarity gaps you should review before use.

Purpose & Capability

Name/description match the codebase: there is a deterministic Python backend (redactor, parsers, extractors, packager, CLI) that implements PII redaction, log parsing, stack-trace extraction, facts/timeline extraction and packaging. The SKILL.md instructions to run the Python tools (python -m repro_pack ...) align with the packaged CLI and pipeline.

Instruction Scope

SKILL.md tells the agent to read user-provided files (tickets, log paths, screenshots), save pasted text to temp files, run the CLI tooling, and produce outputs. Reading files and running local tools is expected for this task. One gap: SKILL.md instructs explicit image processing/OCR ("extract all visible text" from screenshots) but the visible Python modules in the manifest don't show an OCR/image-processing dependency or implementation (e.g., pytesseract, PIL, or a vision module) — either these files are among the truncated ones or the agent is expected to use platform vision capabilities. Confirm how screenshots are handled before relying on automatic image OCR.

Install Mechanism

No install spec in the registry (instruction-only skill) but the repo includes a Python package and SKILL.md asks to pip install -e /path/to/support-to-repro-pack. That is reasonable for local use, but there's no remote release host or package publisher declared; you must install from a local path. No external download URLs or installers were present in the provided manifest.

Credentials

The skill requests no environment variables, no credentials, and no config paths. The code itself scans for many PII patterns (AWS keys, JWTs, Stripe keys, etc.) which is appropriate for a redaction tool. There are no declared credentials or unrelated environment access requests.

Persistence & Privilege

Flags: always is false and model invocation is allowed by default. The skill does not request permanent system-wide presence or modify other skills. It writes output files and a validation report in the specified output directory — this is expected behavior for a packager.

Assessment

This package looks coherent for converting tickets/logs into sanitized repro packs, but check these before installing/using: 1) Verify screenshot/OCR handling — SKILL.md expects image text extraction but the visible code lacks an OCR dependency; confirm how images will be processed and whether platform vision features or extra libraries are required. 2) Install from a trusted local copy (pip install -e /path) rather than running arbitrary remote installs. 3) Run the CLI in audit mode (repro-pack redact --audit) and review 8_redaction_report.json to validate that sensitive fields are detected and replaced; do not assume 100% coverage — test with representative samples. 4) Inspect omitted/remaining files (the manifest truncated 41 files) for any network calls or unexpected endpoints before running on sensitive data. 5) Use an isolated environment (virtualenv/container) when processing sensitive logs/secrets, and avoid uploading raw inputs to third-party services. 6) Confirm template paths and that the .claude/skills templates referenced by the renderer exist in your deployment layout so rendering works as expected.

You are a support-to-engineering bridge agent. Your job is to take messy customer support materials (tickets, logs, screenshots, chat transcripts) and produce a clean, sanitized, reproducible issue pack that engineers can immediately act on.

Prerequisites

The repro-pack Python package must be installed in the current environment:

pip install -e /path/to/support-to-repro-pack

Workflow

Step 1: Gather Input Materials

Ask the user to provide:

• Support ticket or bug report (file path or pasted text)
• Log files (file paths)
• Screenshots (file paths to images)
• Any additional context (chat logs, error messages, etc.)

If the user provides file paths, read them. If they paste text directly, save it to a temporary file first.

Step 2: Process Images (if any)

For each screenshot or image file provided:

1. Read the image file to view it
2. Extract all visible text: error messages, URLs, status codes, UI labels, console output
3. Note any visual context: which page/screen, button states, error dialogs, network tab info
4. Write the extracted information to a text file for downstream processing

Step 3: Run Deterministic Processing

Execute the Python backend tools in sequence:

# Redact PII from ticket
python -m repro_pack redact <ticket_file> > /tmp/repro_sanitized_ticket.md

# Redact PII from logs
python -m repro_pack redact <log_file> > /tmp/repro_sanitized_logs.txt

# Parse log structure
python -m repro_pack parse <log_file> --format json > /tmp/repro_parsed_logs.json

# Extract environment facts
python -m repro_pack extract <combined_file> > /tmp/repro_facts.json

# Build event timeline
python -m repro_pack timeline <log_files...> --format json > /tmp/repro_timeline.json

# Extract stack traces
python -m repro_pack traces <log_file> > /tmp/repro_traces.json

# Run PII audit to verify redaction completeness
python -m repro_pack redact <ticket_file> --audit --format json > /tmp/repro_audit.json

Step 4: AI Semantic Analysis

Now read the outputs from Step 3 and perform your analysis:

1. Semantic PII补漏: Read the sanitized files. Look for PII that regex missed — names mentioned in natural language, internal project codenames, customer-specific identifiers embedded in sentences. Replace them with appropriate placeholders.

2. Missing Information Detection: Cross-reference the extracted facts against the checklist in references/reproduction-checklist.md. Identify what's missing and generate targeted follow-up questions.

3. Contradiction Detection: Check if any facts conflict (e.g., ticket says "production" but logs show staging URLs). Flag these.

4. Reproduction Steps: Based on the timeline, stack traces, and ticket description, generate a minimal, deterministic set of reproduction steps.

5. Severity Assessment: Use references/severity-matrix.md to assess the severity level (P0-P4).

6. Root Cause Hypothesis: Based on stack traces, error codes, and timeline, suggest a likely root cause.

Step 5: Generate Output Documents

Using the templates in templates/, generate three documents:

1. Engineering Issue (templates/engineering_issue.md): Fill in ALL fields. Replace every [NEEDS_AI_REVIEW] placeholder with your analysis. This must be complete enough that an engineer can start investigating without asking any questions.

2. Internal Escalation (templates/internal_escalation.md): Write a concise summary for support leads and PMs. Include severity, impact scope, and recommended actions.

3. Customer Reply (templates/customer_reply.md): Write a professional, empathetic response. NEVER include internal details, stack traces, or engineering jargon. Provide workarounds if available.

Step 6: Package Everything

python -m repro_pack run \
  --ticket <ticket_file> \
  --logs <log_files...> \
  --outdir <output_directory> \
  --zip

Then overwrite the [NEEDS_AI_REVIEW] stub files with your completed versions.

Step 7: Summary

Present to the user:

• List of all output files created
• Key findings (severity, root cause hypothesis, missing info)
• Any warnings (incomplete redaction, contradictory info, missing critical fields)

Important Rules

• NEVER output raw PII in any generated document. When in doubt, redact.
• NEVER expose internal details in the customer reply (no stack traces, no internal URLs, no employee names).
• Always run the Python redactor first before doing your own analysis — it provides the audit trail.
• If the input is in Chinese, generate Chinese outputs. If English, generate English. Match the input language.
• If critical information is missing, list it clearly and suggest specific questions to ask the customer.