mitsupi 1.0.0

package/skills/ghidra/scripts/ghidra_scripts/ExportStrings.java

@@ -0,0 +1,123 @@
+/* ###
+ * Export all strings found in the binary
+ * @category Export
+ */
+
+import ghidra.app.script.GhidraScript;
+import ghidra.program.model.data.DataType;
+import ghidra.program.model.data.StringDataType;
+import ghidra.program.model.listing.Data;
+import ghidra.program.model.listing.DataIterator;
+import ghidra.program.model.mem.Memory;
+import ghidra.program.model.mem.MemoryBlock;
+import ghidra.program.util.DefinedDataIterator;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.PrintWriter;
+
+public class ExportStrings extends GhidraScript {
+
+    @Override
+    public void run() throws Exception {
+        String outputDir = System.getenv("GHIDRA_OUTPUT_DIR");
+        if (outputDir == null || outputDir.isEmpty()) {
+            outputDir = ".";
+        }
+
+        String programName = currentProgram.getName().replaceAll("[^a-zA-Z0-9._-]", "_");
+        File outputFile = new File(outputDir, programName + "_strings.json");
+
+        println("Exporting strings to: " + outputFile.getAbsolutePath());
+
+        try (PrintWriter writer = new PrintWriter(new FileWriter(outputFile))) {
+            writer.println("{");
+            writer.println("  \"program\": \"" + escapeJson(currentProgram.getName()) + "\",");
+            writer.println("  \"strings\": [");
+
+            int count = 0;
+            boolean first = true;
+
+            // Iterate through all defined data looking for strings
+            DataIterator dataIterator = currentProgram.getListing().getDefinedData(true);
+
+            while (dataIterator.hasNext() && !monitor.isCancelled()) {
+                Data data = dataIterator.next();
+
+                if (isStringData(data)) {
+                    String value = getStringValue(data);
+                    if (value != null && !value.isEmpty() && value.length() >= 4) {  // Skip very short strings
+                        if (!first) {
+                            writer.println(",");
+                        }
+                        first = false;
+
+                        writer.println("    {");
+                        writer.println("      \"address\": \"" + data.getAddress() + "\",");
+                        writer.println("      \"type\": \"" + data.getDataType().getName() + "\",");
+                        writer.println("      \"length\": " + value.length() + ",");
+                        writer.println("      \"value\": \"" + escapeJson(truncate(value, 1000)) + "\"");
+                        writer.print("    }");
+                        count++;
+                    }
+                }
+            }
+
+            writer.println();
+            writer.println("  ]");
+            writer.println("}");
+
+            println("Exported " + count + " strings");
+        }
+    }
+
+    private boolean isStringData(Data data) {
+        DataType dt = data.getBaseDataType();
+        String typeName = dt.getName().toLowerCase();
+        return typeName.contains("string") || 
+               typeName.equals("char") ||
+               typeName.contains("unicode");
+    }
+
+    private String getStringValue(Data data) {
+        Object value = data.getValue();
+        if (value instanceof String) {
+            return (String) value;
+        }
+        // Try to get the string representation
+        String repr = data.getDefaultValueRepresentation();
+        if (repr != null && repr.startsWith("\"") && repr.endsWith("\"")) {
+            return repr.substring(1, repr.length() - 1);
+        }
+        return repr;
+    }
+
+    private String truncate(String s, int maxLen) {
+        if (s == null) return "";
+        if (s.length() <= maxLen) return s;
+        return s.substring(0, maxLen) + "...";
+    }
+
+    private String escapeJson(String s) {
+        if (s == null) return "";
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            switch (c) {
+                case '\\': sb.append("\\\\"); break;
+                case '"': sb.append("\\\""); break;
+                case '\n': sb.append("\\n"); break;
+                case '\r': sb.append("\\r"); break;
+                case '\t': sb.append("\\t"); break;
+                case '\b': sb.append("\\b"); break;
+                case '\f': sb.append("\\f"); break;
+                default:
+                    if (c < 32 || c > 126) {
+                        sb.append(String.format("\\u%04x", (int) c));
+                    } else {
+                        sb.append(c);
+                    }
+            }
+        }
+        return sb.toString();
+    }
+}

package/skills/ghidra/scripts/ghidra_scripts/ExportSymbols.java

@@ -0,0 +1,135 @@
+/* ###
+ * Export all symbols and their addresses
+ * @category Export
+ */
+
+import ghidra.app.script.GhidraScript;
+import ghidra.program.model.symbol.*;
+import ghidra.program.model.listing.*;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.PrintWriter;
+
+public class ExportSymbols extends GhidraScript {
+
+    @Override
+    public void run() throws Exception {
+        String outputDir = System.getenv("GHIDRA_OUTPUT_DIR");
+        if (outputDir == null || outputDir.isEmpty()) {
+            outputDir = ".";
+        }
+
+        String programName = currentProgram.getName().replaceAll("[^a-zA-Z0-9._-]", "_");
+        File outputFile = new File(outputDir, programName + "_symbols.json");
+
+        println("Exporting symbols to: " + outputFile.getAbsolutePath());
+
+        SymbolTable symbolTable = currentProgram.getSymbolTable();
+
+        try (PrintWriter writer = new PrintWriter(new FileWriter(outputFile))) {
+            writer.println("{");
+            writer.println("  \"program\": \"" + escapeJson(currentProgram.getName()) + "\",");
+
+            // Export imports (external functions)
+            writer.println("  \"imports\": [");
+            boolean first = true;
+            int importCount = 0;
+            SymbolIterator externalSymbols = symbolTable.getExternalSymbols();
+            while (externalSymbols.hasNext() && !monitor.isCancelled()) {
+                Symbol sym = externalSymbols.next();
+                if (!first) writer.println(",");
+                first = false;
+                writer.println("    {");
+                writer.println("      \"name\": \"" + escapeJson(sym.getName()) + "\",");
+                writer.println("      \"address\": \"" + sym.getAddress() + "\",");
+                writer.println("      \"namespace\": \"" + escapeJson(sym.getParentNamespace().getName()) + "\",");
+                writer.println("      \"type\": \"" + sym.getSymbolType() + "\"");
+                writer.print("    }");
+                importCount++;
+            }
+            writer.println();
+            writer.println("  ],");
+
+            // Export exports (if any)
+            writer.println("  \"exports\": [");
+            first = true;
+            int exportCount = 0;
+            // Functions that are potential exports (entry points or exported)
+            FunctionIterator functions = currentProgram.getFunctionManager().getExternalFunctions();
+            // Look for functions marked as entry points
+            FunctionIterator allFunctions = currentProgram.getFunctionManager().getFunctions(true);
+            while (allFunctions.hasNext() && !monitor.isCancelled()) {
+                Function func = allFunctions.next();
+                // Check if function is at an entry point or has export symbol
+                Symbol sym = func.getSymbol();
+                if (sym.isExternalEntryPoint() || sym.getSource() == SourceType.IMPORTED) {
+                    if (!first) writer.println(",");
+                    first = false;
+                    writer.println("    {");
+                    writer.println("      \"name\": \"" + escapeJson(func.getName()) + "\",");
+                    writer.println("      \"address\": \"" + func.getEntryPoint() + "\",");
+                    writer.println("      \"signature\": \"" + escapeJson(func.getPrototypeString(false, false)) + "\"");
+                    writer.print("    }");
+                    exportCount++;
+                }
+            }
+            writer.println();
+            writer.println("  ],");
+
+            // Export all labels/symbols
+            writer.println("  \"symbols\": [");
+            first = true;
+            int symbolCount = 0;
+            SymbolIterator allSymbols = symbolTable.getAllSymbols(true);
+            while (allSymbols.hasNext() && !monitor.isCancelled()) {
+                Symbol sym = allSymbols.next();
+                // Skip default/dynamic symbols to reduce noise
+                if (sym.getSource() == SourceType.DEFAULT) {
+                    continue;
+                }
+
+                if (!first) writer.println(",");
+                first = false;
+                writer.println("    {");
+                writer.println("      \"name\": \"" + escapeJson(sym.getName()) + "\",");
+                writer.println("      \"address\": \"" + sym.getAddress() + "\",");
+                writer.println("      \"type\": \"" + sym.getSymbolType() + "\",");
+                writer.println("      \"source\": \"" + sym.getSource() + "\",");
+                writer.println("      \"namespace\": \"" + escapeJson(sym.getParentNamespace().getName()) + "\",");
+                writer.println("      \"primary\": " + sym.isPrimary());
+                writer.print("    }");
+                symbolCount++;
+
+                // Limit to prevent huge outputs
+                if (symbolCount >= 10000) {
+                    writer.println(",");
+                    writer.println("    {\"_truncated\": true, \"_message\": \"Output truncated at 10000 symbols\"}");
+                    break;
+                }
+            }
+            writer.println();
+            writer.println("  ],");
+
+            // Summary
+            writer.println("  \"summary\": {");
+            writer.println("    \"imports\": " + importCount + ",");
+            writer.println("    \"exports\": " + exportCount + ",");
+            writer.println("    \"symbols\": " + symbolCount);
+            writer.println("  }");
+
+            writer.println("}");
+
+            println("Exported " + importCount + " imports, " + exportCount + " exports, " + symbolCount + " symbols");
+        }
+    }
+
+    private String escapeJson(String s) {
+        if (s == null) return "";
+        return s.replace("\\", "\\\\")
+                .replace("\"", "\\\"")
+                .replace("\n", "\\n")
+                .replace("\r", "\\r")
+                .replace("\t", "\\t");
+    }
+}

package/skills/github/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: github
+description: "Interact with GitHub using the `gh` CLI. Use `gh issue`, `gh pr`, `gh run`, and `gh api` for issues, PRs, CI runs, and advanced queries."
+---
+
+# GitHub Skill
+
+Use the `gh` CLI to interact with GitHub. Always specify `--repo owner/repo` when not in a git directory, or use URLs directly.
+
+## Pull Requests
+
+Check CI status on a PR:
+```bash
+gh pr checks 55 --repo owner/repo
+```
+
+List recent workflow runs:
+```bash
+gh run list --repo owner/repo --limit 10
+```
+
+View a run and see which steps failed:
+```bash
+gh run view <run-id> --repo owner/repo
+```
+
+View logs for failed steps only:
+```bash
+gh run view <run-id> --repo owner/repo --log-failed
+```
+
+## API for Advanced Queries
+
+The `gh api` command is useful for accessing data not available through other subcommands.
+
+Get PR with specific fields:
+```bash
+gh api repos/owner/repo/pulls/55 --jq '.title, .state, .user.login'
+```
+
+## JSON Output
+
+Most commands support `--json` for structured output.  You can use `--jq` to filter:
+
+```bash
+gh issue list --repo owner/repo --json number,title --jq '.[] | "\(.number): \(.title)"'
+```

package/skills/improve-skill/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: improve-skill
+description: "Analyze coding agent session transcripts to improve existing skills or create new ones. Use when asked to improve a skill based on a session, or extract a new skill from session history."
+---
+
+# Improve Skill
+
+This skill helps analyze coding agent sessions to improve or create skills. It works with Claude Code, Pi, and Codex session files.
+
+## Quick Start
+
+Extract the current session and generate an improvement prompt:
+
+```bash
+# Auto-detect agent and extract current session
+./scripts/extract-session.js
+```
+
+## Session Extraction
+
+The `extract-session.js` script finds and parses session files from any of the three agents:
+
+```bash
+# Auto-detect (uses most recent session for current working directory)
+./scripts/extract-session.js
+
+# Specify agent type
+./scripts/extract-session.js --agent claude
+./scripts/extract-session.js --agent pi
+./scripts/extract-session.js --agent codex
+
+# Specify a different working directory
+./scripts/extract-session.js --cwd /path/to/project
+
+# Use a specific session file
+./scripts/extract-session.js /path/to/session.jsonl
+```
+
+**Session file locations:**
+- **Claude Code**: `~/.claude/projects/<encoded-cwd>/*.jsonl`
+- **Pi**: `~/.pi/agent/sessions/<encoded-cwd>/*.jsonl`
+- **Codex**: `~/.codex/sessions/YYYY/MM/DD/*.jsonl`
+
+## Workflow: Improve an Existing Skill
+
+When asked to improve a skill based on a session:
+
+1. **Extract the session transcript:**
+   ```bash
+   ./scripts/extract-session.js > /tmp/session-transcript.txt
+   ```
+
+2. **Find the existing skill** in one of these locations:
+   - `~/.codex/skills/<skill-name>/SKILL.md`
+   - `~/.claude/skills/<skill-name>/SKILL.md`
+   - `~/.pi/agent/skills/<skill-name>/SKILL.md`
+
+3. **Generate an improvement prompt** for a new session:
+
+```
+═══════════════════════════════════════════════════════════════════════════════
+COPY THE FOLLOWING PROMPT INTO A NEW AGENT SESSION:
+═══════════════════════════════════════════════════════════════════════════════
+
+I need to improve the "<skill-name>" skill based on a session where I used it.
+
+First, read the current skill at: <path-to-skill>
+
+Then analyze this session transcript to understand:
+- Where I struggled to use the skill correctly
+- What information was missing from the skill
+- What examples would have helped
+- What I had to figure out on my own
+
+<session_transcript>
+<paste transcript here>
+</session_transcript>
+
+Based on this analysis, improve the skill by:
+1. Adding missing instructions or clarifications
+2. Adding examples for common use cases discovered
+3. Fixing any incorrect guidance
+4. Making the skill more concise where possible
+
+Write the improved skill back to the same location.
+
+═══════════════════════════════════════════════════════════════════════════════
+```
+
+## Workflow: Create a New Skill
+
+When asked to create a new skill from a session:
+
+1. **Extract the session transcript:**
+   ```bash
+   ./scripts/extract-session.js > /tmp/session-transcript.txt
+   ```
+
+2. **Generate a creation prompt** for a new session:
+
+```
+═══════════════════════════════════════════════════════════════════════════════
+COPY THE FOLLOWING PROMPT INTO A NEW AGENT SESSION:
+═══════════════════════════════════════════════════════════════════════════════
+
+Analyze this session transcript to extract a reusable skill called "<skill-name>":
+
+<session_transcript>
+<paste transcript here>
+</session_transcript>
+
+Create a new skill that captures:
+1. The core capability or workflow demonstrated
+2. Key commands, APIs, or patterns used
+3. Common pitfalls and how to avoid them
+4. Example usage for typical scenarios
+
+Write the skill to: ~/.codex/skills/<skill-name>/SKILL.md
+
+Use this format:
+---
+name: <skill-name>
+description: "<one-line description>"
+---
+
+# <Skill Name> Skill
+
+<overview and quick reference>
+
+## <Section for each major capability>
+
+<instructions and examples>
+
+═══════════════════════════════════════════════════════════════════════════════
+```
+
+## Why a Separate Session?
+
+The improvement prompt is meant to be copied into a **fresh agent session** because:
+
+1. **Token efficiency** - The current session already has a lot of context; starting fresh means only the transcript and skill are loaded
+2. **Clean analysis** - The new session can focus purely on improvement without being influenced by the current task
+3. **Reproducibility** - The prompt is self-contained and can be shared or reused
+
+## Tips for Good Skill Improvements
+
+When analyzing a transcript, look for:
+
+- **Confusion patterns** - Where did the agent retry or change approach?
+- **Missing examples** - What specific commands or code patterns were discovered?
+- **Workarounds** - What did the agent have to figure out that wasn't documented?
+- **Errors** - What failed and how was it resolved?
+- **Successful patterns** - What worked well and should be highlighted?
+
+Keep skills concise - focus on the most important information and examples.