claude-teammate 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Claude Teammate
+
+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,165 @@
+```
+    ____ _                 _        _____                                    _       
+  / ___| | __ _ _   _  __| | ___  |_   _|__  __ _ _ __ ___  _ __ ___   __ _| |_ ___ 
+ | |   | |/ _` | | | |/ _` |/ _ \   | |/ _ \/ _` | '_ ` _ \| '_ ` _ \ / _` | __/ _ \
+ | |___| | (_| | |_| | (_| |  __/   | |  __/ (_| | | | | | | | | | | | (_| | ||  __/
+  \____|_|\__,_|\__,_|\__,_|\___|   |_|\___|\__,_|_| |_| |_|_| |_| |_|\__,_|\__\___|
+```
+
+<p align="center">
+  <a href="#quickstart"><strong>Quickstart</strong></a> &middot;
+  <a href="#how-it-works"><strong>How It Works</strong></a> &middot;
+  <a href="#it-remembers"><strong>It Remembers</strong></a> &middot;
+  <a href="https://github.com/ignify-rd/claude-teammate"><strong>GitHub</strong></a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/ignify-rd/claude-teammate/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT License" /></a>
+</p>
+
+<br/>
+
+# An autonomous software engineer that lives in your Jira and GitHub
+
+Claude Teammate is an AI bot that works around the clock - picking up tickets, writing plans, opening PRs, acting on feedback, and reviewing code. All without being asked.
+
+Assign it tickets. It ships.
+
+|        | Step               | What happens                                                                                          |
+| ------ | ------------------ | ----------------------------------------------------------------------------------------------------- |
+| **01** | Assign the ticket  | Set the Jira assignee to the bot.                                                                     |
+| **02** | It plans           | Reads the codebase and writes a plan. You give feedback, it revises. Nothing moves until you approve. |
+| **03** | It ships           | Opens a PR. Responds to feedback. Keeps going until it's merged.                                      |
+
+<br/>
+
+## Claude Teammate is right for you if
+
+- ✅ You want Jira tickets to **turn into merged PRs** without manual handoff
+- ✅ You want **PR review comments acted on**, not just acknowledged
+- ✅ You need a reviewer that **always shows up** and leaves structured feedback
+- ✅ You want an AI that **remembers** - which repo, what's shipped, what breaks, what to avoid
+- ✅ You want this running on **your own infrastructure**
+
+<br/>
+
+## How It Works
+
+
+<table>
+<tr>
+<td align="center" width="25%">
+<h3>🎫 Jira → GitHub</h3>
+Picks up assigned Jira issues, asks clarifying questions until it has enough context, then creates a GitHub issue with an implementation plan.
+</td>
+<td align="center" width="25%">
+<h3>⚙️ GitHub Issue → PR</h3>
+When the plan is approved, it implements the issue and opens a pull request. No code is written until you sign off.
+</td>
+<td align="center" width="25%">
+<h3>💬 PR Feedback → Fix</h3>
+Review comments don't sit. The bot reads them, fixes the code, and replies - so the only thing left for you to do is approve.
+</td>
+<td align="center" width="25%">
+<h3>🔍 Review Requests</h3>
+Add it as a reviewer and it will show up - every time, with real feedback, never "LGTM" without reading.
+</td>
+</tr>
+</table>
+
+<br/>
+
+## It Remembers
+
+Every epic has its own memory. The bot picks up exactly where it left off - no matter how much time has passed.
+
+```
+memory/
+└── {domain}/
+    └── {workspace}/
+        └── epic-{id}.md
+```
+
+| Field | What it stores |
+|---|---|
+| `repos` | Target GitHub repositories |
+| `status` | Done, in-flight, blocked |
+| `notes` | Architectural decisions, reviewer preferences, conventions |
+| `known issues` | Recurring bugs, fragile areas, patterns to avoid |
+
+The bot carries context across tickets, PRs, and sessions.
+
+<br/>
+
+## Quickstart
+
+**Requirements:** Node.js 20+, [Claude CLI](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated, a Jira API token, a GitHub PAT with repo + PR permissions.
+
+```bash
+npx claude-teammate start
+```
+
+The wizard asks for your Jira and GitHub credentials and writes a `.env` file in the current directory. If the directory is not writable, it exits with a clear error instead of failing silently.
+
+```env
+# .env file generated by `npx claude-teammate start`
+JIRA_BASE_URL=https://yourorg.atlassian.net
+JIRA_EMAIL=you@example.com
+JIRA_API_TOKEN=...
+JIRA_BOT_EMAIL=bot@yourorg.com
+GITHUB_PAT=ghp_...
+```
+
+<br/>
+
+## FAQ
+
+**How is this different from just prompting Claude directly?**
+Claude Teammate is a persistent, scheduled process. It doesn't wait for you to type - it polls, acts, and remembers.
+
+**What happens if a Jira issue lacks context?**
+It asks. The bot comments on the Jira issue with clarifying questions and waits for answers before doing anything.
+
+**Can it handle multiple Jira workspaces and GitHub repos?**
+Yes. Each epic is scoped to its own Jira domain and workspace, and can map to one or more GitHub repositories.
+
+**Does it understand the codebase or just generate generic code?**
+It reads the actual repository before writing anything - structure, conventions, existing patterns. The plan it proposes is specific to your code, not a template.
+
+<br/>
+
+## Roadmap
+
+- 🟢 Design the workflow
+- ⚪ Jira integration - read tickets, comment, detect assignee
+- ⚪ GitHub integration - issues, PRs, review requests
+- ⚪ Epic memory - persistent context per epic
+- ⚪ End-to-end: Jira ticket → approved plan → merged PR
+- ⚪ Publish to npm
+
+<br/>
+
+## Contributing
+
+Contributions are welcome. Open an issue to discuss before submitting large changes.
+
+<br/>
+
+## Community
+
+- [GitHub Issues](https://github.com/ignify-rd/claude-teammate/issues) - bugs and feature requests
+- [GitHub Discussions](https://github.com/ignify-rd/claude-teammate/discussions) - ideas and questions
+
+<br/>
+
+## License
+
+MIT &copy; 2026 Claude Teammate
+
+<br/>
+
+---
+
+<p align="center">
+  <sub>Open source under MIT. Built for engineers who want to ship, not supervise.</sub>
+</p>

package/bin/claude-teammate.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+
+import { runCli } from "../src/cli.js";
+
+try {
+  await runCli(process.argv.slice(2));
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}\n`);
+  process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "claude-teammate",
+  "version": "0.1.0",
+  "description": "CLI bootstrapper for Claude Teammate.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "claude-teammate": "bin/claude-teammate.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "start": "node ./bin/claude-teammate.js start"
+  },
+  "keywords": [
+    "cli",
+    "automation",
+    "jira",
+    "github",
+    "agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ignify-rd/claude-teammate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ignify-rd/claude-teammate/issues"
+  },
+  "homepage": "https://github.com/ignify-rd/claude-teammate#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.23.0",
+    "eslint": "^9.23.0",
+    "globals": "^16.0.0"
+  }
+}

package/src/cli.js

@@ -0,0 +1,32 @@
+import process from "node:process";
+
+import { runStartWizard } from "./commands/start.js";
+
+const HELP_TEXT = `claude-teammate
+
+Usage:
+  claude-teammate start
+  claude-teammate onboard
+  claude-teammate --help
+
+Commands:
+  start     Run the setup wizard and write configuration to .env
+  onboard   Alias for start
+`;
+
+export async function runCli(args) {
+  const [command] = args;
+
+  if (!command || command === "--help" || command === "-h") {
+    process.stdout.write(`${HELP_TEXT}\n`);
+    return;
+  }
+
+  if (command === "start" || command === "onboard") {
+    await runStartWizard();
+    return;
+  }
+
+  process.stderr.write(`Unknown command: ${command}\n\n${HELP_TEXT}\n`);
+  process.exitCode = 1;
+}

package/src/commands/start.js

@@ -0,0 +1,189 @@
+import { access, readFile, writeFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import process from "node:process";
+
+const ENV_PATH = ".env";
+const REQUIRED_FIELDS = [
+  {
+    key: "JIRA_BASE_URL",
+    prompt: "Jira base URL",
+    example: "https://yourorg.atlassian.net"
+  },
+  {
+    key: "JIRA_EMAIL",
+    prompt: "Jira user email",
+    example: "you@example.com"
+  },
+  {
+    key: "JIRA_API_TOKEN",
+    prompt: "Jira API token",
+    secret: true
+  },
+  {
+    key: "JIRA_BOT_EMAIL",
+    prompt: "Bot email used for Jira assignment",
+    example: "bot@yourorg.com"
+  },
+  {
+    key: "GITHUB_PAT",
+    prompt: "GitHub personal access token",
+    secret: true
+  }
+];
+
+export async function runStartWizard() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    process.stderr.write("The start wizard requires an interactive terminal.\n");
+    process.exitCode = 1;
+    return;
+  }
+
+  const existingEnv = await loadExistingEnv();
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    process.stdout.write("Claude Teammate setup\n\n");
+    const values = {};
+
+    for (const field of REQUIRED_FIELDS) {
+      const currentValue = existingEnv[field.key];
+      values[field.key] = await promptForValue(rl, field, currentValue);
+    }
+
+    const envContent = buildEnvFile(values);
+    await persistEnvFile(envContent);
+
+    process.stdout.write(`\nSaved configuration to ${ENV_PATH}.\n`);
+    process.stdout.write("Claude Teammate runtime is not implemented yet.\n");
+  } finally {
+    rl.close();
+  }
+}
+
+async function loadExistingEnv() {
+  try {
+    const currentFile = await readFile(ENV_PATH, "utf8");
+    return parseEnvFile(currentFile);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+
+    throw new Error(`Unable to read ${ENV_PATH}: ${formatError(error)}`);
+  }
+}
+
+async function promptForValue(rl, field, currentValue) {
+  const parts = [field.prompt];
+
+  if (field.example) {
+    parts.push(`example: ${field.example}`);
+  }
+
+  if (currentValue) {
+    parts.push(`current: ${field.secret ? maskSecret(currentValue) : currentValue}`);
+  }
+
+  const answer = await rl.question(`${parts.join(" | ")}\n> `);
+  const trimmed = answer.trim();
+
+  if (trimmed) {
+    return trimmed;
+  }
+
+  if (currentValue) {
+    return currentValue;
+  }
+
+  throw new Error(`Missing required value for ${field.key}.`);
+}
+
+function buildEnvFile(values) {
+  const lines = ["# Generated by `claude-teammate start`"];
+
+  for (const field of REQUIRED_FIELDS) {
+    lines.push(`${field.key}=${escapeEnvValue(values[field.key])}`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+async function persistEnvFile(content) {
+  try {
+    try {
+      await access(".", fsConstants.W_OK);
+    } catch (error) {
+      throw new Error(`Current directory is not writable: ${formatError(error)}`);
+    }
+
+    await writeFile(ENV_PATH, content, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "EACCES") {
+      throw new Error(`No permission to write ${ENV_PATH}.`);
+    }
+
+    throw new Error(`Unable to write ${ENV_PATH}: ${formatError(error)}`);
+  }
+}
+
+function parseEnvFile(content) {
+  const entries = {};
+
+  for (const line of content.split(/\r?\n/u)) {
+    const trimmed = line.trim();
+
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+
+    const separatorIndex = trimmed.indexOf("=");
+    if (separatorIndex === -1) {
+      continue;
+    }
+
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const rawValue = trimmed.slice(separatorIndex + 1).trim();
+    entries[key] = stripWrappedQuotes(rawValue);
+  }
+
+  return entries;
+}
+
+function stripWrappedQuotes(value) {
+  if (
+    (value.startsWith("\"") && value.endsWith("\"")) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+
+  return value;
+}
+
+function escapeEnvValue(value) {
+  if (/^[A-Za-z0-9_./:-]+$/u.test(value)) {
+    return value;
+  }
+
+  return JSON.stringify(value);
+}
+
+function maskSecret(value) {
+  if (value.length <= 4) {
+    return "*".repeat(value.length);
+  }
+
+  return `${"*".repeat(value.length - 4)}${value.slice(-4)}`;
+}
+
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}