claude-attribution 1.0.0

package/src/setup/templates/pr-command.md

@@ -0,0 +1,33 @@
+# Create PR with AI Metrics
+
+Run this when you're ready to open a pull request. Collects AI metrics and creates the PR in one step — no manual copy-paste needed.
+
+## Instructions
+
+```bash
+"{{CLI_BIN}}" pr "feat: your PR title"
+```
+
+This will:
+1. Collect tool usage, model usage, and code attribution for the current session
+2. Read `.github/PULL_REQUEST_TEMPLATE.md` if it exists (uses a built-in template otherwise)
+3. Inject the metrics block into the PR body
+4. Create the PR via `gh pr create` and print the URL
+
+## Options
+
+```bash
+"{{CLI_BIN}}" pr "feat: title" --draft          # Open as draft PR
+"{{CLI_BIN}}" pr "feat: title" --base develop   # Target a different base branch
+"{{CLI_BIN}}" pr                                # Title derived from branch name
+```
+
+## Requirements
+
+- `gh` (GitHub CLI) must be installed and authenticated: `gh auth status`
+
+## Example
+
+```
+/pr "feat: COMM-1234 add user authentication"
+```

package/src/setup/templates/pre-push.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+# Auto-installed by claude-attribution
+# Pushes attribution git notes to origin so GitHub Actions can read them
+"{{CLI_BIN}}" hook pre-push || true

package/src/setup/templates/start-command.md

@@ -0,0 +1,25 @@
+# Start Claude Attribution Session
+
+Run this when beginning work on a new Jira ticket or feature branch.
+Records a start timestamp so /metrics only counts activity from this point forward.
+
+## Instructions
+
+```bash
+"{{CLI_BIN}}" start
+```
+
+This writes a marker to `.claude/attribution-state/session-start` with the current
+timestamp and session ID. The /metrics command uses this to scope tool and token
+counts to the current Jira, even if Claude Code has been running across multiple tickets.
+
+## When to run
+
+- When you `git checkout -b COMM-1234/my-feature` and start a new ticket
+- Any time you want a clean metrics baseline
+
+## Example Usage
+
+```
+/start
+```

package/src/setup/uninstall.ts

@@ -0,0 +1,175 @@
+/**
+ * Uninstaller — removes claude-attribution hooks from a repo.
+ *
+ * Usage: bun src/setup/uninstall.ts [/path/to/target-repo]
+ *
+ * If no path is given, uninstalls from the current working directory.
+ */
+import { readFile, writeFile, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { resolve, join } from "path";
+
+const execFileAsync = promisify(execFile);
+
+interface HookEntry {
+	matcher: string;
+	hooks: Array<{ type: string; command: string }>;
+}
+
+type HooksConfig = Record<string, HookEntry[]>;
+
+interface ClaudeSettings {
+	hooks?: HooksConfig;
+	[key: string]: unknown;
+}
+
+async function stripSettingsHooks(settingsPath: string): Promise<boolean> {
+	if (!existsSync(settingsPath)) return false;
+
+	const raw = await readFile(settingsPath, "utf8");
+	const settings = JSON.parse(raw) as ClaudeSettings;
+	if (!settings.hooks) return false;
+
+	let changed = false;
+	for (const [event, entries] of Object.entries(settings.hooks)) {
+		const filtered = entries.filter(
+			(e) => !e.hooks.some((h) => h.command.includes("claude-attribution")),
+		);
+		if (filtered.length !== entries.length) {
+			settings.hooks[event] = filtered;
+			changed = true;
+		}
+	}
+
+	if (changed) {
+		await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+	}
+	return changed;
+}
+
+async function stripGitHook(hookPath: string): Promise<boolean> {
+	if (!existsSync(hookPath)) return false;
+
+	const content = await readFile(hookPath, "utf8");
+	if (!content.includes("claude-attribution")) return false;
+
+	const marker = "\n# claude-attribution\n";
+	const markerIndex = content.indexOf(marker);
+
+	if (markerIndex !== -1) {
+		const before = content.slice(0, markerIndex).trimEnd();
+
+		if (!before || before === "#!/bin/sh") {
+			// Nothing left but the shebang — remove the file
+			await unlink(hookPath);
+		} else {
+			await writeFile(hookPath, before + "\n");
+		}
+		return true;
+	}
+
+	// Fallback: hook was fully auto-generated (no marker) but contains claude-attribution.
+	// Detect by the "Auto-installed by claude-attribution" header or the hook command pattern.
+	const hasAutoInstallHeader =
+		/^\s*#\s*Auto-installed by claude-attribution/m.test(content);
+	const hasClaudeHookCommand = /claude-attribution[^\n]*\bhook\b/.test(content);
+
+	if (hasAutoInstallHeader || hasClaudeHookCommand) {
+		await unlink(hookPath);
+		return true;
+	}
+
+	// Contains "claude-attribution" in some unrecognized form — be conservative.
+	return false;
+}
+
+async function removeFile(filePath: string): Promise<boolean> {
+	if (!existsSync(filePath)) return false;
+	await unlink(filePath);
+	return true;
+}
+
+async function main() {
+	const targetRepo = resolve(process.argv[2] ?? process.cwd());
+
+	if (!existsSync(join(targetRepo, ".git"))) {
+		console.error(`Error: ${targetRepo} is not a git repository`);
+		process.exit(1);
+	}
+
+	console.log(`Uninstalling claude-attribution from: ${targetRepo}`);
+
+	// 1. Strip hooks from .claude/settings.json
+	const settingsPath = join(targetRepo, ".claude", "settings.json");
+	if (await stripSettingsHooks(settingsPath)) {
+		console.log("✓ Removed hooks from .claude/settings.json");
+	} else {
+		console.log("  (no hooks found in .claude/settings.json)");
+	}
+
+	// 2. Strip/remove post-commit hook (plain git or Husky)
+	const huskyPostCommit = join(targetRepo, ".husky", "post-commit");
+	const plainPostCommit = join(targetRepo, ".git", "hooks", "post-commit");
+	const isHuskyPostCommit = existsSync(huskyPostCommit);
+	const postCommitPath = isHuskyPostCommit ? huskyPostCommit : plainPostCommit;
+	if (await stripGitHook(postCommitPath)) {
+		console.log(
+			`✓ Removed post-commit hook (${isHuskyPostCommit ? ".husky" : ".git/hooks"})`,
+		);
+	} else {
+		console.log("  (no post-commit hook found)");
+	}
+
+	// 3. Strip/remove pre-push hook (plain git or Husky)
+	const huskyPrePush = join(targetRepo, ".husky", "pre-push");
+	const plainPrePush = join(targetRepo, ".git", "hooks", "pre-push");
+	const isHuskyPrePush = existsSync(huskyPrePush);
+	const prePushPath = isHuskyPrePush ? huskyPrePush : plainPrePush;
+	if (await stripGitHook(prePushPath)) {
+		console.log(
+			`✓ Removed pre-push hook (${isHuskyPrePush ? ".husky" : ".git/hooks"})`,
+		);
+	} else {
+		console.log("  (no pre-push hook found)");
+	}
+
+	// 4. Remove remote.origin.push refspec for attribution notes (best-effort)
+	const notesRefspec =
+		"refs/notes/claude-attribution:refs/notes/claude-attribution";
+	try {
+		await execFileAsync(
+			"git",
+			["config", "--unset", "remote.origin.push", notesRefspec],
+			{ cwd: targetRepo },
+		);
+		console.log("✓ Removed remote.origin.push refspec for attribution notes");
+	} catch {
+		// Ignore — refspec may not be present or git may be unavailable
+	}
+
+	// 5. Remove slash commands
+	const commandsDir = join(targetRepo, ".claude", "commands");
+	const metricsRemoved = await removeFile(join(commandsDir, "metrics.md"));
+	const startRemoved = await removeFile(join(commandsDir, "start.md"));
+	const prRemoved = await removeFile(join(commandsDir, "pr.md"));
+	if (metricsRemoved || startRemoved || prRemoved) {
+		const removed = ["metrics.md", "start.md", "pr.md"].filter(
+			(_, i) => [metricsRemoved, startRemoved, prRemoved][i],
+		);
+		console.log(`✓ Removed .claude/commands/${removed.join(", ")}`);
+	} else {
+		console.log("  (no slash commands found)");
+	}
+
+	console.log("\nDone! claude-attribution has been removed from this repo.");
+	console.log(
+		"Note: .claude/logs/ and .claude/attribution-state/ are preserved.",
+	);
+}
+
+main().catch((err) => {
+	console.error("Uninstall failed:", err);
+	process.exit(1);
+});