gsd-vscode-copilot 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# GSD for VS Code + GitHub Copilot
+
+A lightweight planning and execution workflow for building software with AI assistance.
+
+## Installation
+
+```bash
+npx gsd-vscode-copilot
+```
+
+Or install globally:
+
+```bash
+npm install -g gsd-vscode-copilot
+gsd-init
+```
+
+## What it installs
+
+```
+your-project/
+├── .github/
+│   ├── prompts/
+│   │   ├── gsd-bootstrap-planning.prompt.md
+│   │   ├── gsd-plan-slice.prompt.md
+│   │   ├── gsd-execute-plan.prompt.md
+│   │   ├── gsd-verify-work.prompt.md
+│   │   └── gsd-progress.prompt.md
+│   ├── instructions/
+│   │   └── gsd-workflow.instructions.md
+│   └── vendor/
+│       └── get-shit-done/
+│           ├── templates/
+│           │   ├── phase-prompt.md
+│           │   └── summary.md
+│           └── references/
+│               └── checkpoints.md
+└── .planning/
+    ├── PROJECT.md
+    ├── REQUIREMENTS.md
+    ├── ROADMAP.md
+    ├── STATE.md
+    └── phases/
+```
+
+## Usage
+
+### 1. Bootstrap your project
+
+Open `.github/prompts/gsd-bootstrap-planning.prompt.md` and run it with Copilot. This initializes your project memory in `.planning/`.
+
+### 2. Plan a slice
+
+Run `gsd-plan-slice.prompt.md` to create a 2-3 task plan for the next piece of work.
+
+### 3. Execute the plan
+
+Run `gsd-execute-plan.prompt.md` with the path to your plan file.
+
+### 4. Verify (optional)
+
+Run `gsd-verify-work.prompt.md` for conversational user acceptance testing.
+
+### 5. Check progress
+
+Run `gsd-progress.prompt.md` to see where you are and what's next.
+
+## Core Principles
+
+- **Small plans**: 2-3 tasks max per plan
+- **Explicit verification**: Every task has a verify command
+- **Context hygiene**: Fresh context for each plan execution
+- **Atomic commits**: One logical commit per plan
+
+## Stack-Agnostic
+
+The workflow doesn't assume any particular tech stack. Plans carry their own verification commands appropriate to your project:
+
+| Stack | Example verify |
+|-------|----------------|
+| Node | `npm test` |
+| Python | `pytest` |
+| .NET | `dotnet test` |
+| Go | `go test ./...` |
+| Rust | `cargo test` |
+
+## Credits
+
+Inspired by [glittercowboy/get-shit-done](https://github.com/glittercowboy/get-shit-done), adapted for VS Code + GitHub Copilot workflows.
+
+## License
+
+MIT

package/bin/init.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+const TARGET_DIR = process.cwd();
+
+// Colors for terminal output
+const green = (text) => `\x1b[32m${text}\x1b[0m`;
+const yellow = (text) => `\x1b[33m${text}\x1b[0m`;
+const cyan = (text) => `\x1b[36m${text}\x1b[0m`;
+const bold = (text) => `\x1b[1m${text}\x1b[0m`;
+
+console.log(`
+${bold(cyan('╔═══════════════════════════════════════════════════════╗'))}
+${bold(cyan('║'))}  ${bold('GSD for VS Code + GitHub Copilot')}                      ${bold(cyan('║'))}
+${bold(cyan('║'))}  Lightweight planning & execution workflow             ${bold(cyan('║'))}
+${bold(cyan('╚═══════════════════════════════════════════════════════╝'))}
+`);
+
+// Parse args
+const args = process.argv.slice(2);
+const forceOverwrite = args.includes('--force') || args.includes('-f');
+const showHelp = args.includes('--help') || args.includes('-h');
+
+if (showHelp) {
+  console.log(`
+${bold('Usage:')} npx gsd-vscode-copilot [options]
+
+${bold('Options:')}
+  -f, --force    Overwrite existing files
+  -h, --help     Show this help message
+
+${bold('What it does:')}
+  1. Creates .github/prompts/gsd-*.prompt.md  (Copilot prompt files)
+  2. Creates .github/instructions/gsd-workflow.instructions.md
+  3. Creates .github/vendor/get-shit-done/  (templates & workflows)
+  4. Creates .planning/ with PROJECT/REQUIREMENTS/ROADMAP/STATE stubs
+
+${bold('After installing:')}
+  1. Open any gsd-*.prompt.md in VS Code
+  2. Click "Run" or use the Copilot prompt runner
+  3. Start with gsd-bootstrap-planning.prompt.md to initialize your project
+`);
+  process.exit(0);
+}
+
+// Helper: recursively copy directory
+function copyDir(src, dest, options = {}) {
+  const { overwrite = false, createdFiles = [] } = options;
+  
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, { overwrite, createdFiles });
+    } else {
+      if (!fs.existsSync(destPath) || overwrite) {
+        fs.copyFileSync(srcPath, destPath);
+        createdFiles.push(destPath.replace(TARGET_DIR + '/', ''));
+      }
+    }
+  }
+  
+  return createdFiles;
+}
+
+// Helper: create file if not exists (or if force)
+function createFileIfNotExists(filePath, content, overwrite = false) {
+  const fullPath = path.join(TARGET_DIR, filePath);
+  const dir = path.dirname(fullPath);
+  
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  if (!fs.existsSync(fullPath) || overwrite) {
+    fs.writeFileSync(fullPath, content);
+    return true;
+  }
+  return false;
+}
+
+const createdFiles = [];
+const skippedFiles = [];
+
+// 1. Copy prompts
+console.log(`${cyan('→')} Installing Copilot prompt files...`);
+const promptsSrc = path.join(TEMPLATES_DIR, 'prompts');
+const promptsDest = path.join(TARGET_DIR, '.github', 'prompts');
+
+if (fs.existsSync(promptsSrc)) {
+  copyDir(promptsSrc, promptsDest, { overwrite: forceOverwrite, createdFiles });
+}
+
+// 2. Copy vendor (workflows + templates)
+console.log(`${cyan('→')} Installing GSD vendor assets...`);
+const vendorSrc = path.join(TEMPLATES_DIR, 'vendor');
+const vendorDest = path.join(TARGET_DIR, '.github', 'vendor', 'get-shit-done');
+
+if (fs.existsSync(vendorSrc)) {
+  copyDir(vendorSrc, vendorDest, { overwrite: forceOverwrite, createdFiles });
+}
+
+// 3. Create instructions file
+console.log(`${cyan('→')} Installing workflow instructions...`);
+const instructionsPath = '.github/instructions/gsd-workflow.instructions.md';
+const instructionsSrc = path.join(TEMPLATES_DIR, 'gsd-workflow.instructions.md');
+
+if (fs.existsSync(instructionsSrc)) {
+  const content = fs.readFileSync(instructionsSrc, 'utf8');
+  if (createFileIfNotExists(instructionsPath, content, forceOverwrite)) {
+    createdFiles.push(instructionsPath);
+  }
+}
+
+// 4. Create .planning stubs
+console.log(`${cyan('→')} Creating planning directory...`);
+const planningStubsSrc = path.join(TEMPLATES_DIR, 'planning-stubs');
+
+if (fs.existsSync(planningStubsSrc)) {
+  const stubs = fs.readdirSync(planningStubsSrc);
+  for (const stub of stubs) {
+    const content = fs.readFileSync(path.join(planningStubsSrc, stub), 'utf8');
+    const destPath = `.planning/${stub}`;
+    if (createFileIfNotExists(destPath, content, false)) { // Never overwrite planning files
+      createdFiles.push(destPath);
+    } else {
+      skippedFiles.push(destPath);
+    }
+  }
+}
+
+// Create phases directory
+const phasesDir = path.join(TARGET_DIR, '.planning', 'phases');
+if (!fs.existsSync(phasesDir)) {
+  fs.mkdirSync(phasesDir, { recursive: true });
+  createdFiles.push('.planning/phases/');
+}
+
+// Summary
+console.log('');
+console.log(`${green('✓')} ${bold('GSD installed successfully!')}`);
+console.log('');
+
+if (createdFiles.length > 0) {
+  console.log(`${bold('Created:')}`);
+  createdFiles.slice(0, 10).forEach(f => console.log(`  ${green('+')} ${f}`));
+  if (createdFiles.length > 10) {
+    console.log(`  ${cyan('...')} and ${createdFiles.length - 10} more files`);
+  }
+}
+
+if (skippedFiles.length > 0) {
+  console.log('');
+  console.log(`${bold('Skipped (already exist):')}`);
+  skippedFiles.forEach(f => console.log(`  ${yellow('○')} ${f}`));
+}
+
+console.log(`
+${bold('Next steps:')}
+
+  ${cyan('1.')} Open ${bold('.github/prompts/gsd-bootstrap-planning.prompt.md')} in VS Code
+  ${cyan('2.')} Run the prompt with Copilot to initialize your project memory
+  ${cyan('3.')} Use ${bold('gsd-plan-slice.prompt.md')} to create your first plan
+  ${cyan('4.')} Use ${bold('gsd-execute-plan.prompt.md')} to execute it
+
+${bold('Available prompts:')}
+  • gsd-bootstrap-planning  — Initialize .planning/* files
+  • gsd-plan-slice          — Create a 2-3 task plan
+  • gsd-execute-plan        — Execute a plan file
+  • gsd-verify-work         — Conversational UAT
+  • gsd-progress            — Check status and next action
+
+${cyan('Docs:')} .github/vendor/get-shit-done/
+`);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "gsd-vscode-copilot",
+  "version": "1.0.0",
+  "description": "GSD workflow for VS Code + GitHub Copilot. Lightweight planning, execution, and verification system.",
+  "keywords": [
+    "gsd",
+    "get-shit-done",
+    "vscode",
+    "copilot",
+    "github-copilot",
+    "planning",
+    "spec-driven-development",
+    "context-engineering"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/YOUR_ORG/gsd-vscode-copilot"
+  },
+  "bin": {
+    "gsd-vscode-copilot": "./bin/init.js",
+    "gsd-init": "./bin/init.js"
+  },
+  "files": [
+    "bin/",
+    "templates/"
+  ],
+  "engines": {
+    "node": ">=16"
+  }
+}

package/templates/gsd-workflow.instructions.md

@@ -0,0 +1,75 @@
+---
+description: "GSD-style workflow for VS Code + GitHub Copilot (planning + execution)"
+applyTo: "**"
+---
+
+# GSD-Style Workflow (VS Code + Copilot)
+
+This repo uses a lightweight GSD (Get Shit Done) workflow for planning and execution.
+It provides **context hygiene, atomic plans, explicit verification, and disciplined checkpoints**.
+
+## Planning Artifacts (Repository Memory)
+
+Maintain these files under `.planning/`:
+
+| File | Purpose |
+|------|---------|
+| `PROJECT.md` | Product/feature vision, constraints, non-goals |
+| `REQUIREMENTS.md` | v1/v2/out-of-scope requirements (checkable) |
+| `ROADMAP.md` | Phases/slices with links to plan IDs |
+| `STATE.md` | Current position, decisions, blockers, next action |
+
+## Execution Rules
+
+- Prefer automation: if it can be done via CLI/tooling, do it.
+- Plans must be small: **2–3 tasks max** per plan file.
+- Every task must include:
+  - **Action**: what to do and what to avoid (and why)
+  - **Verify**: exact command(s) / checks to prove it worked
+  - **Done**: measurable acceptance criteria
+- Stop for checkpoints only when unavoidable:
+  - human verification (UI/UX),
+  - human decision (architecture/product choice),
+  - auth gates (login/consent needed).
+
+## Plan Format
+
+- Location: `.planning/phases/<NN-name>/<NN-NN-PLAN.md>`
+- Structure: YAML frontmatter + XML tasks (see vendor templates)
+- Reference: `.github/vendor/get-shit-done/templates/phase-prompt.md`
+
+## Workflow Prompts
+
+Use the prompt files in `.github/prompts/`:
+
+| Prompt | When to use |
+|--------|-------------|
+| `gsd-bootstrap-planning.prompt.md` | Initialize `.planning/*` for a new project |
+| `gsd-plan-slice.prompt.md` | Create a 2–3 task plan for the next slice |
+| `gsd-execute-plan.prompt.md` | Execute a plan file |
+| `gsd-verify-work.prompt.md` | Conversational UAT after execution |
+| `gsd-progress.prompt.md` | Check current status and next action |
+
+## STATE.md Discipline
+
+Whenever you:
+- make a decision,
+- discover a constraint,
+- hit a blocker,
+- finish a slice,
+
+…record it in `.planning/STATE.md` with the next action.
+
+## Verification Conventions
+
+Adapt verification commands to your stack:
+
+| Stack | Example verify commands |
+|-------|------------------------|
+| Node/npm | `npm run build`, `npm test` |
+| Python | `pytest`, `python -m mypy .` |
+| .NET | `dotnet build`, `dotnet test` |
+| Go | `go build ./...`, `go test ./...` |
+| Rust | `cargo build`, `cargo test` |
+
+Plans carry the specific verify commands — the workflow is stack-agnostic.

package/templates/planning-stubs/PROJECT.md

@@ -0,0 +1,31 @@
+# Project
+
+## Vision
+
+<!-- What are you building? One paragraph max. -->
+
+TODO: Describe your product/feature vision.
+
+## Constraints
+
+<!-- Hard limits: timeline, budget, tech requirements, integrations -->
+
+- TODO: Add constraints
+
+## Non-Goals
+
+<!-- Explicitly out of scope for this project -->
+
+- TODO: Add non-goals
+
+## Tech Stack
+
+<!-- Languages, frameworks, key libraries -->
+
+- TODO: Define tech stack
+
+## Success Metrics
+
+<!-- How will you know it's working? -->
+
+- TODO: Define success metrics

package/templates/planning-stubs/README.md

@@ -0,0 +1,28 @@
+# .planning
+
+This folder is the project memory for the GSD workflow.
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `PROJECT.md` | Vision, constraints, non-goals |
+| `REQUIREMENTS.md` | Checkable requirements (v1/v2/out-of-scope) |
+| `ROADMAP.md` | Phased slices with status |
+| `STATE.md` | Current position, decisions, next action |
+| `phases/` | Plan and summary files per phase |
+| `uat/` | User acceptance testing notes |
+
+## Workflow
+
+1. **Bootstrap** — Run `gsd-bootstrap-planning.prompt.md` to initialize
+2. **Plan** — Run `gsd-plan-slice.prompt.md` to create a 2-3 task plan
+3. **Execute** — Run `gsd-execute-plan.prompt.md` to implement
+4. **Verify** — Run `gsd-verify-work.prompt.md` for UAT
+5. **Check** — Run `gsd-progress.prompt.md` for status
+
+## Templates
+
+See `.github/vendor/get-shit-done/` for:
+- `templates/phase-prompt.md` — Plan file format
+- `templates/summary.md` — Summary file format

package/templates/planning-stubs/REQUIREMENTS.md

@@ -0,0 +1,21 @@
+# Requirements
+
+## v1 (Must Have)
+
+<!-- Core functionality for initial release -->
+
+- [ ] REQ-01: TODO
+- [ ] REQ-02: TODO
+- [ ] REQ-03: TODO
+
+## v2 (Nice to Have)
+
+<!-- Future enhancements -->
+
+- [ ] REQ-10: TODO
+
+## Out of Scope
+
+<!-- Explicitly excluded -->
+
+- TODO: List what you're NOT building

package/templates/planning-stubs/ROADMAP.md

@@ -0,0 +1,43 @@
+# Roadmap
+
+## Overview
+
+<!-- Brief summary of the milestone -->
+
+Building: TODO
+
+## Phases
+
+### Phase 1: Foundation
+**Goal:** TODO - What this phase delivers
+**Requirements:** REQ-01, REQ-02
+**Status:** Not started
+
+Plans:
+- [ ] 01-01: TODO
+
+### Phase 2: Core Features  
+**Goal:** TODO
+**Requirements:** REQ-03
+**Depends on:** Phase 1
+**Status:** Not started
+
+Plans:
+- [ ] 02-01: TODO
+
+### Phase 3: Polish & Ship
+**Goal:** TODO
+**Requirements:** REQ-04
+**Depends on:** Phase 2
+**Status:** Not started
+
+Plans:
+- [ ] 03-01: TODO
+
+## Progress
+
+| Phase | Plans | Status | Completed |
+|-------|-------|--------|-----------|
+| 1. Foundation | 0/1 | Not started | - |
+| 2. Core Features | 0/1 | Not started | - |
+| 3. Polish & Ship | 0/1 | Not started | - |

package/templates/planning-stubs/STATE.md

@@ -0,0 +1,33 @@
+# State
+
+## Project Reference
+
+- **Project:** See PROJECT.md
+- **Last updated:** TODO
+
+## Current Position
+
+- **Phase:** 1 of 3 (Foundation)
+- **Plan:** Not started
+- **Status:** Ready to plan
+- **Last activity:** Project initialized
+
+Progress: ░░░░░░░░░░ 0%
+
+## Decisions
+
+| Phase | Decision | Rationale |
+|-------|----------|-----------|
+| - | - | - |
+
+## Blockers / Concerns
+
+<!-- Active blockers preventing progress -->
+
+None
+
+## Session Continuity
+
+- **Last session:** TODO
+- **Stopped at:** Project initialized
+- **Resume with:** Run `gsd-plan-slice` for Phase 1

package/templates/prompts/gsd-bootstrap-planning.prompt.md

@@ -0,0 +1,52 @@
+---
+description: "GSD: Bootstrap planning files (.planning/*)"
+argument-hint: "Optional: tell me the product vision, constraints, and near-term goals."
+agent: agent
+---
+
+Create (or update) the repository planning artifacts under `.planning/`.
+
+## What to do
+
+1. If `.planning/` does not exist, create it.
+2. If the files below do not exist, create them with lightweight templates.
+3. If they already exist, do not rewrite them wholesale—only refine headings and fill obvious missing essentials.
+
+## Files to ensure exist
+
+- `.planning/PROJECT.md` — Product vision, constraints, non-goals
+- `.planning/REQUIREMENTS.md` — v1/v2/out-of-scope requirements (checkable)
+- `.planning/ROADMAP.md` — Phased slices with status tracking
+- `.planning/STATE.md` — Current position, decisions, blockers, next action
+
+Also ensure the phase workspace exists:
+- `.planning/phases/` (for `*-PLAN.md` and `*-SUMMARY.md` files)
+
+## Style
+
+- Keep content concise and skimmable.
+- Prefer checklists and short bullets.
+- Don't invent product decisions—ask questions where needed.
+
+## Questions
+
+Before writing substantial content, ask me the minimum set of questions needed to make these files useful (aim for 5–10). Example questions:
+
+1. What is the core product/feature you're building?
+2. Who is the primary user?
+3. What technology stack are you using?
+4. What are 3–5 must-have features for v1?
+5. What's explicitly out of scope?
+6. Any hard constraints (timeline, budget, existing systems)?
+7. How will you verify the work? (test commands, CI, manual checks)
+
+## Output
+
+After creating/updating files, summarize:
+- What was created
+- What needs my input next
+- The recommended next prompt to run
+
+Point to the vendor templates if helpful:
+- `.github/vendor/get-shit-done/templates/phase-prompt.md`
+- `.github/vendor/get-shit-done/templates/summary.md`