plcode-windows-x64-baseline 2.1.0

package/.plcode/skill/core/browser/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "plcode-browser-skill",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "puppeteer-core": "24.43.1"
+  }
+}

package/.plcode/skill/core/browser/pick.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import puppeteer from "puppeteer-core"
+
+const prompt = process.argv[2] || "Click elements to select them"
+
+async function main() {
+  const browser = await puppeteer.connect({
+    browserURL: "http://localhost:9222",
+  })
+
+  const pages = await browser.pages()
+  const page = pages[0]
+
+  if (!page) {
+    console.error("No active page found")
+    process.exit(1)
+  }
+
+  console.log(`Prompt: ${prompt}`)
+  console.log("Click to select, Ctrl+Click for multi-select, Enter to finish")
+
+  const result = await page.evaluate(async (promptText) => {
+    return new Promise((resolve) => {
+      const selected = []
+      let overlay = document.createElement("div")
+      overlay.id = "__picker_overlay__"
+      overlay.style.cssText =
+        "position:fixed;top:0;left:0;right:0;padding:10px;background:rgba(0,0,0,0.8);color:white;z-index:999999;font-family:monospace;font-size:12px;"
+      overlay.textContent = promptText + " | Click: select | Ctrl+Click: multi | Enter: done"
+      document.body.appendChild(overlay)
+
+      let highlight = document.createElement("div")
+      highlight.id = "__picker_highlight__"
+      highlight.style.cssText =
+        "position:absolute;border:2px solid #00ff00;background:rgba(0,255,0,0.1);pointer-events:none;z-index:999998;display:none;"
+      document.body.appendChild(highlight)
+
+      function getElementInfo(el) {
+        return {
+          tag: el.tagName.toLowerCase(),
+          id: el.id || null,
+          classes: Array.from(el.classList),
+          text: el.textContent?.trim().slice(0, 100) || null,
+          href: el.href || null,
+        }
+      }
+
+      function updateHighlight(el) {
+        const rect = el.getBoundingClientRect()
+        highlight.style.display = "block"
+        highlight.style.top = rect.top + window.scrollY + "px"
+        highlight.style.left = rect.left + window.scrollX + "px"
+        highlight.style.width = rect.width + "px"
+        highlight.style.height = rect.height + "px"
+      }
+
+      function cleanup() {
+        document.removeEventListener("mouseover", onMouseOver)
+        document.removeEventListener("click", onClick, true)
+        document.removeEventListener("keydown", onKeyDown)
+        overlay.remove()
+        highlight.remove()
+      }
+
+      function onMouseOver(e) {
+        updateHighlight(e.target)
+      }
+
+      function onClick(e) {
+        e.preventDefault()
+        e.stopPropagation()
+        const info = getElementInfo(e.target)
+        selected.push(info)
+        console.log("Selected:", info)
+        if (!e.ctrlKey && !e.metaKey) {
+          cleanup()
+          resolve(selected)
+        }
+      }
+
+      function onKeyDown(e) {
+        if (e.key === "Enter") {
+          cleanup()
+          resolve(selected)
+        } else if (e.key === "Escape") {
+          cleanup()
+          resolve([])
+        }
+      }
+
+      document.addEventListener("mouseover", onMouseOver)
+      document.addEventListener("click", onClick, true)
+      document.addEventListener("keydown", onKeyDown)
+    })
+  }, prompt)
+
+  console.log("\nSelected elements:")
+  console.log(JSON.stringify(result, null, 2))
+
+  browser.disconnect()
+}
+
+main().catch((err) => {
+  console.error("Error:", err.message)
+  process.exit(1)
+})

package/.plcode/skill/core/browser/screenshot.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import puppeteer from "puppeteer-core"
+import { join } from "path"
+import { tmpdir } from "os"
+
+async function main() {
+  const browser = await puppeteer.connect({
+    browserURL: "http://localhost:9222",
+  })
+
+  const pages = await browser.pages()
+  const page = pages[0]
+
+  if (!page) {
+    console.error("No active page found")
+    process.exit(1)
+  }
+
+  const filename = `screenshot-${Date.now()}.png`
+  const filepath = join(tmpdir(), filename)
+
+  await page.screenshot({ path: filepath })
+  console.log(`✓ Screenshot saved: ${filepath}`)
+
+  browser.disconnect()
+}
+
+main().catch((err) => {
+  console.error("Error:", err.message)
+  process.exit(1)
+})

package/.plcode/skill/core/browser/start.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { spawn } from "child_process"
+import { existsSync, mkdirSync, cpSync } from "fs"
+import { join } from "path"
+import { homedir, tmpdir, platform } from "os"
+
+const args = process.argv.slice(2)
+const useProfile = args.includes("--profile")
+
+function getChromePath() {
+  const paths =
+    platform() === "win32"
+      ? [
+          join(process.env["PROGRAMFILES"] || "", "Google/Chrome/Application/chrome.exe"),
+          join(process.env["PROGRAMFILES(X86)"] || "", "Google/Chrome/Application/chrome.exe"),
+          join(process.env["LOCALAPPDATA"] || "", "Google/Chrome/Application/chrome.exe"),
+        ]
+      : platform() === "darwin"
+        ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"]
+        : ["/usr/bin/google-chrome", "/usr/bin/chromium-browser", "/usr/bin/chromium"]
+
+  for (const p of paths) {
+    if (existsSync(p)) return p
+  }
+  throw new Error("Chrome not found")
+}
+
+function getUserDataDir() {
+  if (platform() === "win32") {
+    return join(process.env["LOCALAPPDATA"] || "", "Google/Chrome/User Data")
+  } else if (platform() === "darwin") {
+    return join(homedir(), "Library/Application Support/Google/Chrome")
+  }
+  return join(homedir(), ".config/google-chrome")
+}
+
+async function main() {
+  const chromePath = getChromePath()
+  const tempProfile = join(tmpdir(), `chrome-debug-${Date.now()}`)
+  mkdirSync(tempProfile, { recursive: true })
+
+  if (useProfile) {
+    const userDataDir = getUserDataDir()
+    const defaultProfile = join(userDataDir, "Default")
+    if (existsSync(defaultProfile)) {
+      console.log("Copying Chrome profile...")
+      cpSync(defaultProfile, join(tempProfile, "Default"), { recursive: true })
+    }
+  }
+
+  const chromeArgs = [
+    `--remote-debugging-port=9222`,
+    `--user-data-dir=${tempProfile}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+  ]
+
+  const child = spawn(chromePath, chromeArgs, {
+    detached: true,
+    stdio: "ignore",
+  })
+  child.unref()
+
+  await new Promise((resolve) => setTimeout(resolve, 2000))
+  console.log(`✓ Chrome started on :9222${useProfile ? " with your profile" : ""}`)
+}
+
+main().catch((err) => {
+  console.error("Error:", err.message)
+  process.exit(1)
+})

package/.plcode/skill/core/changelog-generator/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: changelog-generator
+description: Automatically creates user-facing changelogs from git commits by analyzing commit history, categorizing changes, and transforming technical commits into clear, customer-friendly release notes. Turns hours of manual changelog writing into minutes of automated generation.
+category: documents
+---
+
+# Changelog Generator
+
+This skill transforms technical git commits into polished, user-friendly changelogs that your customers and users will actually understand and appreciate.
+
+## When to Use This Skill
+
+- Preparing release notes for a new version
+- Creating weekly or monthly product update summaries
+- Documenting changes for customers
+- Writing changelog entries for app store submissions
+- Generating update notifications
+- Creating internal release documentation
+- Maintaining a public changelog/product updates page
+
+## What This Skill Does
+
+1. **Scans Git History**: Analyzes commits from a specific time period or between versions
+2. **Categorizes Changes**: Groups commits into logical categories (features, improvements, bug fixes, breaking changes, security)
+3. **Translates Technical → User-Friendly**: Converts developer commits into customer language
+4. **Formats Professionally**: Creates clean, structured changelog entries
+5. **Filters Noise**: Excludes internal commits (refactoring, tests, etc.)
+6. **Follows Best Practices**: Applies changelog guidelines and your brand voice
+
+## How to Use
+
+### Basic Usage
+
+From your project repository:
+
+```
+Create a changelog from commits since last release
+```
+
+```
+Generate changelog for all commits from the past week
+```
+
+```
+Create release notes for version 2.5.0
+```
+
+### With Specific Date Range
+
+```
+Create a changelog for all commits between March 1 and March 15
+```
+
+### With Custom Guidelines
+
+```
+Create a changelog for commits since v2.4.0, using my changelog
+guidelines from CHANGELOG_STYLE.md
+```
+
+## Example
+
+**User**: "Create a changelog for commits from the past 7 days"
+
+**Output**:
+
+```markdown
+# Updates - Week of March 10, 2024
+
+## ✨ New Features
+
+- **Team Workspaces**: Create separate workspaces for different
+  projects. Invite team members and keep everything organized.
+
+- **Keyboard Shortcuts**: Press ? to see all available shortcuts.
+  Navigate faster without touching your mouse.
+
+## 🔧 Improvements
+
+- **Faster Sync**: Files now sync 2x faster across devices
+- **Better Search**: Search now includes file contents, not just titles
+
+## 🐛 Fixes
+
+- Fixed issue where large images wouldn't upload
+- Resolved timezone confusion in scheduled posts
+- Corrected notification badge count
+```
+
+**Inspired by:** Manik Aggarwal's use case from Lenny's Newsletter
+
+## Tips
+
+- Run from your git repository root
+- Specify date ranges for focused changelogs
+- Use your CHANGELOG_STYLE.md for consistent formatting
+- Review and adjust the generated changelog before publishing
+- Save output directly to CHANGELOG.md
+
+## Related Use Cases
+
+- Creating GitHub release notes
+- Writing app store update descriptions
+- Generating email updates for users
+- Creating social media announcement posts

package/.plcode/skill/core/clarify/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: clarify
+description: Improve unclear UX copy, error messages, microcopy, labels, and instructions. Makes interfaces easier to understand and use.
+category: design
+args:
+  - name: target
+    description: The feature or component with unclear copy (optional)
+    required: false
+user-invokable: true
+---
+
+Identify and improve unclear, confusing, or poorly written interface text to make the product easier to understand and use.
+
+## Assess Current Copy
+
+Identify what makes the text unclear or ineffective:
+
+1. **Find clarity problems**:
+   - **Jargon**: Technical terms users won't understand
+   - **Ambiguity**: Multiple interpretations possible
+   - **Passive voice**: "Your file has been uploaded" vs "We uploaded your file"
+   - **Length**: Too wordy or too terse
+   - **Assumptions**: Assuming user knowledge they don't have
+   - **Missing context**: Users don't know what to do or why
+   - **Tone mismatch**: Too formal, too casual, or inappropriate for situation
+
+2. **Understand the context**:
+   - Who's the audience? (Technical? General? First-time users?)
+   - What's the user's mental state? (Stressed during error? Confident during success?)
+   - What's the action? (What do we want users to do?)
+   - What's the constraint? (Character limits? Space limitations?)
+
+**CRITICAL**: Clear copy helps users succeed. Unclear copy creates frustration, errors, and support tickets.
+
+## Plan Copy Improvements
+
+Create a strategy for clearer communication:
+
+- **Primary message**: What's the ONE thing users need to know?
+- **Action needed**: What should users do next (if anything)?
+- **Tone**: How should this feel? (Helpful? Apologetic? Encouraging?)
+- **Constraints**: Length limits, brand voice, localization considerations
+
+**IMPORTANT**: Good UX writing is invisible. Users should understand immediately without noticing the words.
+
+## Improve Copy Systematically
+
+Refine text across these common areas:
+
+### Error Messages
+
+**Bad**: "Error 403: Forbidden"
+**Good**: "You don't have permission to view this page. Contact your admin for access."
+
+**Bad**: "Invalid input"
+**Good**: "Email addresses need an @ symbol. Try: name@example.com"
+
+**Principles**:
+
+- Explain what went wrong in plain language
+- Suggest how to fix it
+- Don't blame the user
+- Include examples when helpful
+- Link to help/support if applicable
+
+### Form Labels & Instructions
+
+**Bad**: "DOB (MM/DD/YYYY)"
+**Good**: "Date of birth" (with placeholder showing format)
+
+**Bad**: "Enter value here"
+**Good**: "Your email address" or "Company name"
+
+**Principles**:
+
+- Use clear, specific labels (not generic placeholders)
+- Show format expectations with examples
+- Explain why you're asking (when not obvious)
+- Put instructions before the field, not after
+- Keep required field indicators clear
+
+### Button & CTA Text
+
+**Bad**: "Click here" | "Submit" | "OK"
+**Good**: "Create account" | "Save changes" | "Got it, thanks"
+
+**Principles**:
+
+- Describe the action specifically
+- Use active voice (verb + noun)
+- Match user's mental model
+- Be specific ("Save" is better than "OK")
+
+### Help Text & Tooltips
+
+**Bad**: "This is the username field"
+**Good**: "Choose a username. You can change this later in Settings."
+
+**Principles**:
+
+- Add value (don't just repeat the label)
+- Answer the implicit question ("What is this?" or "Why do you need this?")
+- Keep it brief but complete
+- Link to detailed docs if needed
+
+### Empty States
+
+**Bad**: "No items"
+**Good**: "No projects yet. Create your first project to get started."
+
+**Principles**:
+
+- Explain why it's empty (if not obvious)
+- Show next action clearly
+- Make it welcoming, not dead-end
+
+### Success Messages
+
+**Bad**: "Success"
+**Good**: "Settings saved! Your changes will take effect immediately."
+
+**Principles**:
+
+- Confirm what happened
+- Explain what happens next (if relevant)
+- Be brief but complete
+- Match the user's emotional moment (celebrate big wins)
+
+### Loading States
+
+**Bad**: "Loading..." (for 30+ seconds)
+**Good**: "Analyzing your data... this usually takes 30-60 seconds"
+
+**Principles**:
+
+- Set expectations (how long?)
+- Explain what's happening (when it's not obvious)
+- Show progress when possible
+- Offer escape hatch if appropriate ("Cancel")
+
+### Confirmation Dialogs
+
+**Bad**: "Are you sure?"
+**Good**: "Delete 'Project Alpha'? This can't be undone."
+
+**Principles**:
+
+- State the specific action
+- Explain consequences (especially for destructive actions)
+- Use clear button labels ("Delete project" not "Yes")
+- Don't overuse confirmations (only for risky actions)
+
+### Navigation & Wayfinding
+
+**Bad**: Generic labels like "Items" | "Things" | "Stuff"
+**Good**: Specific labels like "Your projects" | "Team members" | "Settings"
+
+**Principles**:
+
+- Be specific and descriptive
+- Use language users understand (not internal jargon)
+- Make hierarchy clear
+- Consider information scent (breadcrumbs, current location)
+
+## Apply Clarity Principles
+
+Every piece of copy should follow these rules:
+
+1. **Be specific**: "Enter email" not "Enter value"
+2. **Be concise**: Cut unnecessary words (but don't sacrifice clarity)
+3. **Be active**: "Save changes" not "Changes will be saved"
+4. **Be human**: "Oops, something went wrong" not "System error encountered"
+5. **Be helpful**: Tell users what to do, not just what happened
+6. **Be consistent**: Use same terms throughout (don't vary for variety)
+
+**NEVER**:
+
+- Use jargon without explanation
+- Blame users ("You made an error" → "This field is required")
+- Be vague ("Something went wrong" without explanation)
+- Use passive voice unnecessarily
+- Write overly long explanations (be concise)
+- Use humor for errors (be empathetic instead)
+- Assume technical knowledge
+- Vary terminology (pick one term and stick with it)
+- Repeat information (headers restating intros, redundant explanations)
+- Use placeholders as the only labels (they disappear when users type)
+
+## Verify Improvements
+
+Test that copy improvements work:
+
+- **Comprehension**: Can users understand without context?
+- **Actionability**: Do users know what to do next?
+- **Brevity**: Is it as short as possible while remaining clear?
+- **Consistency**: Does it match terminology elsewhere?
+- **Tone**: Is it appropriate for the situation?
+
+Remember: You're a clarity expert with excellent communication skills. Write like you're explaining to a smart friend who's unfamiliar with the product. Be clear, be helpful, be human.