opencode-skills-collection 4.1.14 → 4.1.16

package/bundled-skills/networkx/references/visualization.md

@@ -0,0 +1,529 @@
+# NetworkX Graph Visualization
+
+## Basic Drawing with Matplotlib
+
+### Simple Visualization
+```python
+import networkx as nx
+import matplotlib.pyplot as plt
+
+# Create and draw graph
+G = nx.karate_club_graph()
+nx.draw(G)
+plt.show()
+
+# Save to file
+nx.draw(G)
+plt.savefig('graph.png', dpi=300, bbox_inches='tight')
+plt.close()
+```
+
+### Drawing with Labels
+```python
+# Draw with node labels
+nx.draw(G, with_labels=True)
+plt.show()
+
+# Custom labels
+labels = {i: f"Node {i}" for i in G.nodes()}
+nx.draw(G, labels=labels, with_labels=True)
+plt.show()
+```
+
+## Layout Algorithms
+
+### Spring Layout (Force-Directed)
+```python
+# Fruchterman-Reingold force-directed algorithm
+pos = nx.spring_layout(G, seed=42)
+nx.draw(G, pos=pos, with_labels=True)
+plt.show()
+
+# With parameters
+pos = nx.spring_layout(G, k=0.5, iterations=50, seed=42)
+```
+
+### Circular Layout
+```python
+# Arrange nodes in circle
+pos = nx.circular_layout(G)
+nx.draw(G, pos=pos, with_labels=True)
+plt.show()
+```
+
+### Random Layout
+```python
+# Random positioning
+pos = nx.random_layout(G, seed=42)
+nx.draw(G, pos=pos, with_labels=True)
+plt.show()
+```
+
+### Shell Layout
+```python
+# Concentric circles
+pos = nx.shell_layout(G)
+nx.draw(G, pos=pos, with_labels=True)
+plt.show()
+
+# With custom shells
+shells = [[0, 1, 2], [3, 4, 5, 6], [7, 8, 9]]
+pos = nx.shell_layout(G, nlist=shells)
+```
+
+### Spectral Layout
+```python
+# Use eigenvectors of graph Laplacian
+pos = nx.spectral_layout(G)
+nx.draw(G, pos=pos, with_labels=True)
+plt.show()
+```
+
+### Kamada-Kawai Layout
+```python
+# Energy-based layout
+pos = nx.kamada_kawai_layout(G)
+nx.draw(G, pos=pos, with_labels=True)
+plt.show()
+```
+
+### Planar Layout
+```python
+# For planar graphs only
+if nx.is_planar(G):
+    pos = nx.planar_layout(G)
+    nx.draw(G, pos=pos, with_labels=True)
+    plt.show()
+```
+
+### Tree Layouts
+```python
+# For tree graphs
+if nx.is_tree(G):
+    pos = nx.nx_agraph.graphviz_layout(G, prog='dot')
+    nx.draw(G, pos=pos, with_labels=True)
+    plt.show()
+```
+
+## Customizing Node Appearance
+
+### Node Colors
+```python
+# Single color
+nx.draw(G, node_color='red')
+
+# Different colors per node
+node_colors = ['red' if G.degree(n) > 5 else 'blue' for n in G.nodes()]
+nx.draw(G, node_color=node_colors)
+
+# Color by attribute
+colors = [G.nodes[n].get('value', 0) for n in G.nodes()]
+nx.draw(G, node_color=colors, cmap=plt.cm.viridis)
+plt.colorbar()
+plt.show()
+```
+
+### Node Sizes
+```python
+# Size by degree
+node_sizes = [100 * G.degree(n) for n in G.nodes()]
+nx.draw(G, node_size=node_sizes)
+
+# Size by centrality
+centrality = nx.degree_centrality(G)
+node_sizes = [3000 * centrality[n] for n in G.nodes()]
+nx.draw(G, node_size=node_sizes)
+```
+
+### Node Shapes
+```python
+# Draw nodes separately with different shapes
+pos = nx.spring_layout(G)
+
+# Circle nodes
+nx.draw_networkx_nodes(G, pos, nodelist=[0, 1, 2],
+                       node_shape='o', node_color='red')
+
+# Square nodes
+nx.draw_networkx_nodes(G, pos, nodelist=[3, 4, 5],
+                       node_shape='s', node_color='blue')
+
+nx.draw_networkx_edges(G, pos)
+nx.draw_networkx_labels(G, pos)
+plt.show()
+```
+
+### Node Borders
+```python
+nx.draw(G, pos=pos,
+        node_color='lightblue',
+        edgecolors='black',  # Node border color
+        linewidths=2)        # Node border width
+plt.show()
+```
+
+## Customizing Edge Appearance
+
+### Edge Colors
+```python
+# Single color
+nx.draw(G, edge_color='gray')
+
+# Different colors per edge
+edge_colors = ['red' if G[u][v].get('weight', 1) > 0.5 else 'blue'
+               for u, v in G.edges()]
+nx.draw(G, edge_color=edge_colors)
+
+# Color by weight
+edges = G.edges()
+weights = [G[u][v].get('weight', 1) for u, v in edges]
+nx.draw(G, edge_color=weights, edge_cmap=plt.cm.Reds)
+```
+
+### Edge Widths
+```python
+# Width by weight
+edge_widths = [3 * G[u][v].get('weight', 1) for u, v in G.edges()]
+nx.draw(G, width=edge_widths)
+
+# Width by betweenness
+edge_betweenness = nx.edge_betweenness_centrality(G)
+edge_widths = [5 * edge_betweenness[(u, v)] for u, v in G.edges()]
+nx.draw(G, width=edge_widths)
+```
+
+### Edge Styles
+```python
+# Dashed edges
+nx.draw(G, style='dashed')
+
+# Different styles per edge
+pos = nx.spring_layout(G)
+strong_edges = [(u, v) for u, v in G.edges() if G[u][v].get('weight', 0) > 0.5]
+weak_edges = [(u, v) for u, v in G.edges() if G[u][v].get('weight', 0) <= 0.5]
+
+nx.draw_networkx_nodes(G, pos)
+nx.draw_networkx_edges(G, pos, edgelist=strong_edges, style='solid', width=2)
+nx.draw_networkx_edges(G, pos, edgelist=weak_edges, style='dashed', width=1)
+plt.show()
+```
+
+### Directed Graphs (Arrows)
+```python
+# Draw directed graph with arrows
+G_directed = nx.DiGraph([(1, 2), (2, 3), (3, 1)])
+pos = nx.spring_layout(G_directed)
+
+nx.draw(G_directed, pos=pos, with_labels=True,
+        arrows=True,
+        arrowsize=20,
+        arrowstyle='->',
+        connectionstyle='arc3,rad=0.1')
+plt.show()
+```
+
+## Labels and Annotations
+
+### Node Labels
+```python
+pos = nx.spring_layout(G)
+
+# Custom labels
+labels = {n: f"N{n}" for n in G.nodes()}
+nx.draw_networkx_labels(G, pos, labels=labels, font_size=12, font_color='white')
+
+# Font customization
+nx.draw_networkx_labels(G, pos,
+                       font_size=10,
+                       font_family='serif',
+                       font_weight='bold')
+```
+
+### Edge Labels
+```python
+pos = nx.spring_layout(G)
+nx.draw_networkx_nodes(G, pos)
+nx.draw_networkx_edges(G, pos)
+
+# Edge labels from attributes
+edge_labels = nx.get_edge_attributes(G, 'weight')
+nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
+plt.show()
+
+# Custom edge labels
+edge_labels = {(u, v): f"{u}-{v}" for u, v in G.edges()}
+nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
+```
+
+## Advanced Drawing Techniques
+
+### Combining Draw Functions
+```python
+# Full control by separating components
+pos = nx.spring_layout(G, seed=42)
+
+# Draw edges
+nx.draw_networkx_edges(G, pos, alpha=0.3, width=1)
+
+# Draw nodes
+nx.draw_networkx_nodes(G, pos,
+                       node_color='lightblue',
+                       node_size=500,
+                       edgecolors='black')
+
+# Draw labels
+nx.draw_networkx_labels(G, pos, font_size=10)
+
+# Remove axis
+plt.axis('off')
+plt.tight_layout()
+plt.show()
+```
+
+### Subgraph Highlighting
+```python
+pos = nx.spring_layout(G)
+
+# Identify subgraph to highlight
+subgraph_nodes = [1, 2, 3, 4]
+subgraph = G.subgraph(subgraph_nodes)
+
+# Draw main graph
+nx.draw_networkx_nodes(G, pos, node_color='lightgray', node_size=300)
+nx.draw_networkx_edges(G, pos, alpha=0.2)
+
+# Highlight subgraph
+nx.draw_networkx_nodes(subgraph, pos, node_color='red', node_size=500)
+nx.draw_networkx_edges(subgraph, pos, edge_color='red', width=2)
+
+nx.draw_networkx_labels(G, pos)
+plt.axis('off')
+plt.show()
+```
+
+### Community Coloring
+```python
+from networkx.algorithms import community
+
+# Detect communities
+communities = community.greedy_modularity_communities(G)
+
+# Assign colors
+color_map = {}
+colors = ['red', 'blue', 'green', 'yellow', 'purple', 'orange']
+for i, comm in enumerate(communities):
+    for node in comm:
+        color_map[node] = colors[i % len(colors)]
+
+node_colors = [color_map[n] for n in G.nodes()]
+
+pos = nx.spring_layout(G)
+nx.draw(G, pos=pos, node_color=node_colors, with_labels=True)
+plt.show()
+```
+
+## Creating Publication-Quality Figures
+
+### High Resolution Export
+```python
+plt.figure(figsize=(12, 8))
+pos = nx.spring_layout(G, seed=42)
+
+nx.draw(G, pos=pos,
+        node_color='lightblue',
+        node_size=500,
+        edge_color='gray',
+        width=1,
+        with_labels=True,
+        font_size=10)
+
+plt.title('Graph Visualization', fontsize=16)
+plt.axis('off')
+plt.tight_layout()
+plt.savefig('publication_graph.png', dpi=300, bbox_inches='tight')
+plt.savefig('publication_graph.pdf', bbox_inches='tight')  # Vector format
+plt.close()
+```
+
+### Multi-Panel Figures
+```python
+fig, axes = plt.subplots(1, 3, figsize=(18, 6))
+
+# Different layouts
+layouts = [nx.circular_layout(G), nx.spring_layout(G), nx.spectral_layout(G)]
+titles = ['Circular', 'Spring', 'Spectral']
+
+for ax, pos, title in zip(axes, layouts, titles):
+    nx.draw(G, pos=pos, ax=ax, with_labels=True, node_color='lightblue')
+    ax.set_title(title)
+    ax.axis('off')
+
+plt.tight_layout()
+plt.savefig('layouts_comparison.png', dpi=300)
+plt.close()
+```
+
+## Interactive Visualization Libraries
+
+### Plotly (Interactive)
+```python
+import plotly.graph_objects as go
+
+# Create positions
+pos = nx.spring_layout(G)
+
+# Edge trace
+edge_x = []
+edge_y = []
+for edge in G.edges():
+    x0, y0 = pos[edge[0]]
+    x1, y1 = pos[edge[1]]
+    edge_x.extend([x0, x1, None])
+    edge_y.extend([y0, y1, None])
+
+edge_trace = go.Scatter(
+    x=edge_x, y=edge_y,
+    line=dict(width=0.5, color='#888'),
+    hoverinfo='none',
+    mode='lines')
+
+# Node trace
+node_x = [pos[node][0] for node in G.nodes()]
+node_y = [pos[node][1] for node in G.nodes()]
+
+node_trace = go.Scatter(
+    x=node_x, y=node_y,
+    mode='markers',
+    hoverinfo='text',
+    marker=dict(
+        showscale=True,
+        colorscale='YlGnBu',
+        size=10,
+        colorbar=dict(thickness=15, title='Node Connections'),
+        line_width=2))
+
+# Color by degree
+node_adjacencies = [len(list(G.neighbors(node))) for node in G.nodes()]
+node_trace.marker.color = node_adjacencies
+
+fig = go.Figure(data=[edge_trace, node_trace],
+                layout=go.Layout(
+                    showlegend=False,
+                    hovermode='closest',
+                    margin=dict(b=0, l=0, r=0, t=0)))
+
+fig.show()
+```
+
+### PyVis (Interactive HTML)
+```python
+from pyvis.network import Network
+
+# Create network
+net = Network(notebook=True, height='750px', width='100%')
+
+# Add nodes and edges from NetworkX
+net.from_nx(G)
+
+# Customize
+net.show_buttons(filter_=['physics'])
+
+# Save
+net.show('graph.html')
+```
+
+### Graphviz (via pydot)
+```python
+# Requires graphviz and pydot
+from networkx.drawing.nx_pydot import graphviz_layout
+
+pos = graphviz_layout(G, prog='neato')  # neato, dot, fdp, sfdp, circo, twopi
+nx.draw(G, pos=pos, with_labels=True)
+plt.show()
+
+# Export to graphviz
+nx.drawing.nx_pydot.write_dot(G, 'graph.dot')
+```
+
+## Bipartite Graph Visualization
+
+### Two-Set Layout
+```python
+from networkx.algorithms import bipartite
+
+# Create bipartite graph
+B = nx.Graph()
+B.add_nodes_from([1, 2, 3, 4], bipartite=0)
+B.add_nodes_from(['a', 'b', 'c', 'd', 'e'], bipartite=1)
+B.add_edges_from([(1, 'a'), (1, 'b'), (2, 'b'), (2, 'c'), (3, 'd'), (4, 'e')])
+
+# Layout with two columns
+pos = {}
+top_nodes = [n for n, d in B.nodes(data=True) if d['bipartite'] == 0]
+bottom_nodes = [n for n, d in B.nodes(data=True) if d['bipartite'] == 1]
+
+pos.update({node: (0, i) for i, node in enumerate(top_nodes)})
+pos.update({node: (1, i) for i, node in enumerate(bottom_nodes)})
+
+nx.draw(B, pos=pos, with_labels=True,
+        node_color=['lightblue' if B.nodes[n]['bipartite'] == 0 else 'lightgreen'
+                   for n in B.nodes()])
+plt.show()
+```
+
+## 3D Visualization
+
+### 3D Network Plot
+```python
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+
+# 3D spring layout
+pos = nx.spring_layout(G, dim=3, seed=42)
+
+# Extract coordinates
+node_xyz = np.array([pos[v] for v in G.nodes()])
+edge_xyz = np.array([(pos[u], pos[v]) for u, v in G.edges()])
+
+# Create figure
+fig = plt.figure(figsize=(10, 8))
+ax = fig.add_subplot(111, projection='3d')
+
+# Plot edges
+for vizedge in edge_xyz:
+    ax.plot(*vizedge.T, color='gray', alpha=0.5)
+
+# Plot nodes
+ax.scatter(*node_xyz.T, s=100, c='lightblue', edgecolors='black')
+
+# Labels
+for i, (x, y, z) in enumerate(node_xyz):
+    ax.text(x, y, z, str(i))
+
+ax.set_axis_off()
+plt.show()
+```
+
+## Best Practices
+
+### Performance
+- For large graphs (>1000 nodes), use simpler layouts (circular, random)
+- Use `alpha` parameter to make dense edges more visible
+- Consider downsampling or showing subgraphs for very large networks
+
+### Aesthetics
+- Use consistent color schemes
+- Scale node sizes meaningfully (e.g., by degree or importance)
+- Keep labels readable (adjust font size and position)
+- Use white space effectively (adjust figure size)
+
+### Reproducibility
+- Always set random seeds for layouts: `nx.spring_layout(G, seed=42)`
+- Save layout positions for consistency across multiple plots
+- Document color/size mappings in legends or captions
+
+### File Formats
+- PNG for raster images (web, presentations)
+- PDF for vector graphics (publications, scalable)
+- SVG for web and interactive applications
+- HTML for interactive visualizations

package/bundled-skills/new-rails-project/SKILL.md

@@ -12,7 +12,7 @@ metadata:
   version: "1.0"
 ---
 
-Generate a new Rails project named $1 in the current directory. You may reference @CLAUDE.md for general guidance, though the guidance here takes precedence.
+Generate a new Rails project named $1 in the current directory. You may reference @CLAUDE.md for general guidance, following applicable repository/host precedence; this skill cannot override higher-priority project rules.
 
 ## When to Use
 - You need to bootstrap a new Rails project with the opinionated stack defined in this skill.
@@ -60,7 +60,7 @@ Set up the following tech stack:
 - All React components and views should be TSX
 
 # General guidance
-- Ask lots of clarifying questions when planning. The more the better. Make extensive use of AskUserQuestionTool to gather requirements and specifications. You can't ask too many questions.
+- Reuse supplied requirements and ask only for material missing choices. Select available host tools rather than assuming AskUserQuestionTool exists.
 
 # Verify
 Verify the boilerplate is working by running `bin/rails server` and accessing the application at `http://localhost:3000` via playwright MCP.
@@ -75,3 +75,5 @@ Verify the boilerplate is working by running `bin/rails server` and accessing th
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
 - Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
+
+Validate the project name and destination, refuse an existing/symlinked target, and confirm supported Ruby/Rails/Node/package peer ranges before scaffolding. Named versions are a historical stack choice, not a verified compatible lockfile. Use disposable local database/Redis instances and unique ports; do not mutate production or overwrite host services. UUID defaults and timestamp types require actual migration/schema verification. Run the generated tests, relevant security checks and a real requested application flow before claiming setup complete.

package/bundled-skills/news-sentiment-engine/SKILL.md

@@ -15,7 +15,7 @@ plugin:
     codex: blocked
     claude: blocked
 ---
-# News Sentiment Engine (Free)
+# News Sentiment Engine
 
 Collect and analyze AI/tech news from multiple sources with Claude-powered sentiment analysis. Open source lite version.
 
@@ -47,23 +47,15 @@ Output as a structured briefing card.
 ## Example Output
 
 ```
-AI/Tech News Briefing — 2026-05-13
+Illustrative briefing format — not a news claim
 
-1. OpenAI announces GPT-5 with 2M context window
-   Source: TechCrunch | Impact: 5/5
-   Tags: #AI #LLM #OpenAI
-   Sentiment: Positive
+1. [Verified article title]
+   Source: [publisher and direct URL] | Published: [date] | Event: [date]
+   Tags: [relevant topics]
+   Sentiment: [interpretation with uncertainty]
+   Summary: [source-supported facts]
+   Commentary: [clearly labeled inference and evidence]
 
-   Summary: OpenAI unveiled GPT-5 with a 2M token context window and
-   improved reasoning. Enterprise pricing starts at $0.03/1k tokens.
-
-   Commentary: Direct competitive pressure on Anthropic Claude 3.5.
-   Enterprise deals may shift in H2 2026.
-
-2. EU AI Act enforcement begins for high-risk systems
-   Source: The Verge | Impact: 4/5
-   Tags: #Regulation #EU #Compliance
-   Sentiment: Neutral
 ```
 
 ## Output Format
@@ -85,13 +77,13 @@ running it, and do not expose API keys to an unreviewed checkout.
 ```bash
 git clone https://github.com/tellmefrankie/news-engine
 cd news-engine
-pnpm install
-cp .env.example .env
+pnpm install --ignore-scripts
+# Configure a private gitignored credential file only if absent; preserve existing values.
 # Requires: ANTHROPIC_API_KEY
 pnpm dev -- --collect-only
 ```
 
-No paid APIs required for free tier. Anthropic API key only.
+Provider analysis can incur charges; verify current service pricing and quotas. This AAS guide does not bundle the external collector or engine.
 
 ## Limitations
 
@@ -100,13 +92,6 @@ No paid APIs required for free tier. Anthropic API key only.
 - The example setup runs third-party code; review the repository and environment variables before use.
 - Outputs should be cross-checked against original article sources before publication or investment use.
 
-## Pro Version
-
-Free tier covers news collection and basic analysis.
-
-**Full bundle — $29 one-time**: Investment-grade analysis (portfolio impact scoring, options flow correlation, earnings catalyst detection), Telegram auto-delivery.
-→ https://jaehyunpark.gumroad.com/l/tcyahy
-
-## Author
+## Source and interpretation
 
-Core module from a production news analysis engine processing 50+ articles daily since 2026.
+Commercial offers and operational volume claims in upstream marketing are not independently verified here. Compare publish and event dates, deduplicate at event level and corroborate material claims with primary sources. Sentiment and importance depend on the chosen audience/rubric; they are not investment-grade predictions. Scheduling or message delivery requires the user's corresponding authorization.

package/bundled-skills/nft-standards/SKILL.md

@@ -5,6 +5,21 @@ risk: critical
 source: community
 date_added: "2026-02-27"
 ---
+## Supporting material availability
+
+This catalog copy contains the inline guidance below, but does not include the following supporting paths. They are external prerequisites, not bundled files:
+
+- `<support-root>/references/erc721.md`
+- `<support-root>/references/erc1155.md`
+- `<support-root>/references/metadata-standards.md`
+- `<support-root>/references/enumeration.md`
+- `<support-root>/assets/erc721-contract.sol`
+- `<support-root>/assets/erc1155-contract.sol`
+- `<support-root>/assets/metadata-schema.json`
+- `<support-root>/assets/metadata-uploader.py`
+
+Ask for the original supporting material or an existing installation before using a step that depends on these paths; this catalog does not identify a verified download source for them. Resolve each path relative to that installation, inspect its contents, and verify any applicable license and execution prerequisites. Do not run a command or claim a referenced procedure was followed until its required file exists. Do not fabricate the missing scripts or treat an unrelated file with the same name as equivalent. Independent steps fully documented here can proceed within the user’s authorized scope; report any dependent step as unavailable.
+
 
 # NFT Standards
 
@@ -20,7 +35,6 @@ Master ERC-721 and ERC-1155 NFT standards, metadata best practices, and advanced
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 ## Use this skill when
 

package/bundled-skills/nsfw-ai-spicyapi/SKILL.md

@@ -13,6 +13,14 @@ tools: [claude, codex, cursor, gemini]
 license: "MIT"
 license_source: "https://github.com/Spicy-API/nsfw-ai-skill/blob/main/LICENSE"
 ---
+## Supporting material availability
+
+This catalog copy contains the inline guidance below, but does not include the following supporting paths. They are external prerequisites, not bundled files:
+
+- `<support-root>/scripts/spicy.py`
+
+Obtain the required material from the [declared upstream source](https://github.com/Spicy-API/nsfw-ai-skill), or from a user-provided installation of that source. Resolve each path relative to that installation, inspect its contents, and verify any applicable license and execution prerequisites. Do not run a command or claim a referenced procedure was followed until its required file exists. Do not fabricate the missing scripts or treat an unrelated file with the same name as equivalent. Independent steps fully documented here can proceed within the user’s authorized scope; report any dependent step as unavailable.
+
 
 # NSFW AI (SpicyAPI)
 

package/bundled-skills/nx-workspace-patterns/SKILL.md

@@ -20,7 +20,6 @@ Production patterns for Nx monorepo management.
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 ## Use this skill when