ralphctl 0.1.0 → 0.1.2

package/dist/create-MG7E7PLQ.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  sprintCreateCommand
+} from "./chunk-JON4GCLR.mjs";
+import "./chunk-EKMZZRWI.mjs";
+import "./chunk-6PYTKGB5.mjs";
+import "./chunk-QBXHAXHI.mjs";
+export {
+  sprintCreateCommand
+};

package/dist/handle-UG5M2OON.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+// src/completion/handle.ts
+async function handleCompletionRequest(program) {
+  const env = process.env;
+  if (!env["COMP_CWORD"] || !env["COMP_POINT"] || !env["COMP_LINE"]) {
+    return false;
+  }
+  const tabtab = (await import("tabtab")).default;
+  const { resolveCompletions } = await import("./resolver-WSFWKACM.mjs");
+  const tabEnv = tabtab.parseEnv(env);
+  const completions = await resolveCompletions(program, {
+    line: tabEnv.line,
+    last: tabEnv.last,
+    prev: tabEnv.prev
+  });
+  tabtab.log(completions);
+  return true;
+}
+export {
+  handleCompletionRequest
+};

package/dist/multiline-OHSNFCRG.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import {
+  icons,
+  muted
+} from "./chunk-QBXHAXHI.mjs";
+
+// src/utils/multiline.ts
+import * as readline from "readline";
+async function multilineInput(options) {
+  const { message, default: defaultValue, hint = "Ctrl+D to finish" } = options;
+  console.log(`${icons.edit} ${message} ${muted(`(${hint})`)}`);
+  if (defaultValue) {
+    console.log(muted("  Default:"));
+    for (const line of defaultValue.split("\n")) {
+      console.log(muted(`    ${line}`));
+    }
+    console.log("");
+  }
+  const lines = [];
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: process.stdin.isTTY
+  });
+  return new Promise((resolve) => {
+    rl.on("line", (line) => {
+      lines.push(line);
+    });
+    rl.on("close", () => {
+      console.log("");
+      while (lines.length > 0 && lines.at(-1)?.trim() === "") {
+        lines.pop();
+      }
+      resolve(lines.join("\n"));
+    });
+  });
+}
+export {
+  multilineInput
+};

package/dist/project-NT3L4FTB.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import {
+  ProjectExistsError,
+  ProjectNotFoundError,
+  addProjectRepo,
+  createProject,
+  getProject,
+  getProjectRepos,
+  listProjects,
+  projectExists,
+  removeProject,
+  removeProjectRepo,
+  updateProject
+} from "./chunk-WGHJI3OI.mjs";
+import "./chunk-6PYTKGB5.mjs";
+export {
+  ProjectExistsError,
+  ProjectNotFoundError,
+  addProjectRepo,
+  createProject,
+  getProject,
+  getProjectRepos,
+  listProjects,
+  projectExists,
+  removeProject,
+  removeProjectRepo,
+  updateProject
+};

package/dist/resolver-WSFWKACM.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+// src/completion/resolver.ts
+var dynamicResolvers = {
+  "--project": async () => {
+    try {
+      const { listProjects } = await import("./project-NT3L4FTB.mjs");
+      const projects = await listProjects();
+      return projects.map((p) => ({ name: p.name, description: p.displayName }));
+    } catch {
+      return [];
+    }
+  },
+  "--status": () => {
+    return Promise.resolve([
+      { name: "draft", description: "Draft sprints" },
+      { name: "active", description: "Active sprints" },
+      { name: "closed", description: "Closed sprints" },
+      { name: "todo", description: "Todo tasks" },
+      { name: "in_progress", description: "In-progress tasks" },
+      { name: "done", description: "Done tasks" },
+      { name: "pending", description: "Pending requirements" },
+      { name: "approved", description: "Approved requirements" }
+    ]);
+  }
+};
+var configKeyCompletions = [
+  { name: "provider", description: "AI provider (claude or copilot)" },
+  { name: "editor", description: "External editor for multiline input" }
+];
+var configValueCompletions = {
+  provider: [
+    { name: "claude", description: "Claude Code CLI" },
+    { name: "copilot", description: "GitHub Copilot CLI" }
+  ]
+};
+async function getSprintCompletions() {
+  try {
+    const { listSprints } = await import("./sprint-4VHDLGFN.mjs");
+    const sprints = await listSprints();
+    return sprints.map((s) => ({
+      name: s.id,
+      description: `${s.name} (${s.status})`
+    }));
+  } catch {
+    return [];
+  }
+}
+function getSubcommands(cmd) {
+  return cmd.commands.map((sub) => ({
+    name: sub.name(),
+    description: sub.description()
+  }));
+}
+function getOptions(cmd) {
+  const items = [];
+  for (const opt of cmd.options) {
+    const flag = opt.long ?? opt.short;
+    if (flag) {
+      items.push({ name: flag, description: opt.description });
+    }
+  }
+  return items;
+}
+function findSubcommand(cmd, name) {
+  return cmd.commands.find((sub) => sub.name() === name);
+}
+function optionExpectsValue(cmd, flag) {
+  const opt = cmd.options.find((o) => o.long === flag || o.short === flag);
+  if (!opt) return false;
+  return opt.required || opt.optional;
+}
+function parseWords(line) {
+  return line.trim().split(/\s+/).slice(1);
+}
+async function resolveCompletions(program, ctx) {
+  const words = parseWords(ctx.line);
+  let currentCmd = program;
+  let wordIndex = 0;
+  while (wordIndex < words.length) {
+    const word = words[wordIndex];
+    if (!word) break;
+    if (word.startsWith("-")) {
+      wordIndex++;
+      if (optionExpectsValue(currentCmd, word) && wordIndex < words.length) {
+        wordIndex++;
+      }
+      continue;
+    }
+    const sub = findSubcommand(currentCmd, word);
+    if (sub) {
+      currentCmd = sub;
+      wordIndex++;
+    } else {
+      break;
+    }
+  }
+  const cmdPath = getCommandPath(currentCmd);
+  if (cmdPath === "config set") {
+    return resolveConfigSetCompletions(words, ctx);
+  }
+  if (ctx.prev.startsWith("-")) {
+    const resolver = dynamicResolvers[ctx.prev];
+    if (resolver) {
+      return resolver();
+    }
+    if (optionExpectsValue(currentCmd, ctx.prev)) {
+      return [];
+    }
+  }
+  if (ctx.last.startsWith("-")) {
+    return getOptions(currentCmd);
+  }
+  const subs = getSubcommands(currentCmd);
+  if (subs.length > 0) {
+    return subs;
+  }
+  if (cmdPath.startsWith("sprint ") && acceptsPositionalArg(currentCmd)) {
+    return getSprintCompletions();
+  }
+  return [];
+}
+function getCommandPath(cmd) {
+  const parts = [];
+  let current = cmd;
+  while (current?.parent) {
+    parts.unshift(current.name());
+    current = current.parent;
+  }
+  return parts.join(" ");
+}
+function acceptsPositionalArg(cmd) {
+  return cmd.registeredArguments.length > 0;
+}
+function resolveConfigSetCompletions(words, ctx) {
+  const setIndex = words.indexOf("set");
+  if (setIndex === -1) {
+    return Promise.resolve(configKeyCompletions);
+  }
+  const argsAfterSet = words.slice(setIndex + 1).filter((w) => !w.startsWith("-"));
+  if (argsAfterSet.length === 0) {
+    return Promise.resolve(configKeyCompletions);
+  }
+  if (argsAfterSet.length === 1 && ctx.last !== "") {
+    return Promise.resolve(configKeyCompletions);
+  }
+  const key = argsAfterSet[0];
+  const values = key ? configValueCompletions[key] : void 0;
+  return Promise.resolve(values ?? []);
+}
+export {
+  resolveCompletions
+};

package/dist/sprint-4VHDLGFN.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import {
+  NoCurrentSprintError,
+  SprintNotFoundError,
+  SprintStatusError,
+  activateSprint,
+  assertSprintStatus,
+  closeSprint,
+  createSprint,
+  deleteSprint,
+  findActiveSprint,
+  getActiveSprintOrThrow,
+  getCurrentSprintOrThrow,
+  getSprint,
+  listSprints,
+  resolveSprintId,
+  saveSprint
+} from "./chunk-EKMZZRWI.mjs";
+import "./chunk-6PYTKGB5.mjs";
+import "./chunk-QBXHAXHI.mjs";
+export {
+  NoCurrentSprintError,
+  SprintNotFoundError,
+  SprintStatusError,
+  activateSprint,
+  assertSprintStatus,
+  closeSprint,
+  createSprint,
+  deleteSprint,
+  findActiveSprint,
+  getActiveSprintOrThrow,
+  getCurrentSprintOrThrow,
+  getSprint,
+  listSprints,
+  resolveSprintId,
+  saveSprint
+};

package/dist/wizard-LRELAN2J.mjs

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import {
+  sprintPlanCommand,
+  sprintRefineCommand,
+  sprintStartCommand
+} from "./chunk-LOR7QBXX.mjs";
+import "./chunk-NTWO2LXB.mjs";
+import {
+  sprintCreateCommand
+} from "./chunk-JON4GCLR.mjs";
+import {
+  addSingleTicketInteractive
+} from "./chunk-MNMQC36F.mjs";
+import "./chunk-7TG3EAQ2.mjs";
+import "./chunk-WGHJI3OI.mjs";
+import {
+  getCurrentSprint,
+  getSprint
+} from "./chunk-EKMZZRWI.mjs";
+import "./chunk-6PYTKGB5.mjs";
+import {
+  colors,
+  emoji,
+  icons,
+  log,
+  printHeader,
+  printSeparator,
+  progressBar,
+  showSuccess,
+  showWarning
+} from "./chunk-QBXHAXHI.mjs";
+
+// src/interactive/wizard.ts
+import { confirm } from "@inquirer/prompts";
+var TOTAL_STEPS = 5;
+function showStepProgress(step, title) {
+  const bar = progressBar(step - 1, TOTAL_STEPS, { width: 10, showPercent: false });
+  log.newline();
+  printSeparator();
+  console.log(`  ${colors.highlight(`Step ${String(step)} of ${String(TOTAL_STEPS)}`)}  ${bar}  ${title}`);
+  log.newline();
+}
+async function runWizard() {
+  try {
+    printHeader("Sprint Setup Wizard", emoji.donut);
+    log.dim("This wizard will guide you through setting up a new sprint.");
+    log.dim("You can skip optional steps along the way.");
+    log.newline();
+    showStepProgress(1, "Create Sprint");
+    try {
+      await sprintCreateCommand({ interactive: true });
+    } catch (err) {
+      if (err instanceof Error) {
+        log.error(`Sprint creation failed: ${err.message}`);
+      }
+      log.newline();
+      showWarning("Cannot continue without a sprint. Wizard aborted.");
+      return;
+    }
+    const sprintId = await getCurrentSprint();
+    if (!sprintId) {
+      showWarning("No current sprint set. Wizard aborted.");
+      return;
+    }
+    showStepProgress(2, "Add Tickets");
+    let ticketCount = 0;
+    let addMore = true;
+    while (addMore) {
+      try {
+        const ticket = await addSingleTicketInteractive({});
+        if (ticket) {
+          ticketCount++;
+        } else {
+          break;
+        }
+      } catch (err) {
+        if (err instanceof Error) {
+          log.error(`Failed to add ticket: ${err.message}`);
+        }
+      }
+      log.newline();
+      addMore = await confirm({
+        message: `${emoji.donut} Add another ticket?`,
+        default: true
+      });
+    }
+    if (ticketCount === 0) {
+      log.newline();
+      showWarning("No tickets added. You can add them later with: ralphctl ticket add");
+    }
+    showStepProgress(3, "Refine Requirements");
+    if (ticketCount === 0) {
+      log.dim("Skipped -- no tickets to refine.");
+    } else {
+      const shouldRefine = await confirm({
+        message: `${emoji.donut} Refine requirements now?`,
+        default: true
+      });
+      if (shouldRefine) {
+        try {
+          await sprintRefineCommand([]);
+        } catch (err) {
+          if (err instanceof Error) {
+            log.error(`Refinement failed: ${err.message}`);
+          }
+          log.dim("You can refine later with: ralphctl sprint refine");
+        }
+      } else {
+        log.dim("Skipped. You can refine later with: ralphctl sprint refine");
+      }
+    }
+    showStepProgress(4, "Plan Tasks");
+    let canPlan = false;
+    try {
+      const sprint = await getSprint(sprintId);
+      const hasTickets = sprint.tickets.length > 0;
+      const allApproved = hasTickets && sprint.tickets.every((t) => t.requirementStatus === "approved");
+      canPlan = allApproved;
+      if (!hasTickets) {
+        log.dim("Skipped -- no tickets to plan.");
+      } else if (!allApproved) {
+        log.dim("Skipped -- not all requirements are approved yet.");
+        log.dim("Refine first with: ralphctl sprint refine");
+      }
+    } catch {
+      log.dim("Skipped -- could not read sprint state.");
+    }
+    if (canPlan) {
+      const shouldPlan = await confirm({
+        message: `${emoji.donut} Generate tasks now?`,
+        default: true
+      });
+      if (shouldPlan) {
+        try {
+          await sprintPlanCommand([]);
+        } catch (err) {
+          if (err instanceof Error) {
+            log.error(`Planning failed: ${err.message}`);
+          }
+          log.dim("You can plan later with: ralphctl sprint plan");
+        }
+      } else {
+        log.dim("Skipped. You can plan later with: ralphctl sprint plan");
+      }
+    }
+    showStepProgress(5, "Start Execution");
+    const shouldStart = await confirm({
+      message: `${emoji.donut} Start execution now?`,
+      default: false
+    });
+    if (shouldStart) {
+      try {
+        await sprintStartCommand([]);
+      } catch (err) {
+        if (err instanceof Error) {
+          log.error(`Execution failed: ${err.message}`);
+        }
+      }
+      return;
+    }
+    log.newline();
+    printSeparator();
+    showSuccess("Wizard complete!");
+    log.newline();
+    try {
+      const sprint = await getSprint(sprintId);
+      log.info(`Sprint "${sprint.name}" is ready.`);
+      log.item(`${icons.ticket}  ${String(sprint.tickets.length)} ticket(s)`);
+      const approvedCount = sprint.tickets.filter((t) => t.requirementStatus === "approved").length;
+      if (sprint.tickets.length > 0) {
+        log.item(`${icons.success}  ${String(approvedCount)}/${String(sprint.tickets.length)} requirements approved`);
+      }
+    } catch {
+    }
+    log.newline();
+    log.dim("Next steps:");
+    if (ticketCount === 0) {
+      log.item("ralphctl ticket add --project <name>");
+    }
+    log.item("ralphctl sprint refine");
+    log.item("ralphctl sprint plan");
+    log.item("ralphctl sprint start");
+    log.newline();
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      log.newline();
+      showWarning("Wizard cancelled");
+      log.newline();
+      return;
+    }
+    throw err;
+  }
+}
+export {
+  runWizard
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralphctl",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Sprint and task management CLI for AI-assisted coding",
   "homepage": "https://github.com/lukas-grigis/ralphctl",
   "type": "module",
@@ -24,37 +24,15 @@
     "developer-tools"
   ],
   "bin": {
-    "ralphctl": "./bin/ralphctl"
+    "ralphctl": "./dist/cli.mjs"
   },
   "files": [
-    "bin/",
-    "src/",
-    "!src/**/*.test.ts",
-    "!src/test-utils/",
-    "!src/integration/",
-    "schemas/",
-    "tsconfig.json",
-    "README.md",
-    "LICENSE",
-    "CHANGELOG.md"
+    "dist/",
+    "schemas/"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc --noEmit",
-    "dev": "tsx src/cli.ts",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "prepare": "husky"
-  },
-  "packageManager": "pnpm@10.29.3",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -65,7 +43,6 @@
     "gradient-string": "^3.0.0",
     "ora": "^9.3.0",
     "tabtab": "^3.0.2",
-    "tsx": "^4.21.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
@@ -78,6 +55,8 @@
     "husky": "^9.1.7",
     "lint-staged": "^16.3.1",
     "prettier": "^3.8.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.56.1",
     "vitest": "^4.0.18"
@@ -88,5 +67,17 @@
       "prettier --write"
     ],
     "*.{md,json,yml,yaml}": "prettier --write"
+  },
+  "scripts": {
+    "build": "tsup && mkdir -p dist/prompts && cp src/ai/prompts/*.md dist/prompts/",
+    "dev": "tsx src/cli.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   }
-}
+}

package/CHANGELOG.md

@@ -1,94 +0,0 @@
-# Changelog
-
-All notable changes to RalphCTL will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project adheres to [Semantic Versioning](https://semver.org/).
-
-## [0.1.0] - 2026-03-07
-
-### Added
-
-- **npm publishing** — `ralphctl` is now available via `npm install -g ralphctl`
-- Release pipeline publishes to npm and creates GitHub Releases with changelog-based notes
-
-### Changed
-
-- Streamlined README for end-user onboarding with `npm install -g` as primary install method
-- Added release process documentation to CONTRIBUTING.md
-- Version bumped to 0.1.0 for first public npm release
-
-## [0.0.3] - 2026-03-06
-
-### Changed
-
-- Normalized git author identity across commit history
-- Updated package metadata for open-source release (description, homepage, private flag)
-- Moved `tsx` from devDependencies to dependencies (runtime requirement for `bin/ralphctl`)
-- Fixed stale path references in SECURITY.md, CONTRIBUTING.md, and agent memory files
-- Fixed changelog compare link in release workflow to include `v` prefix
-- Corrected documentation table descriptions in README.md
-- Cleaned up stale `dist/` build artifacts
-- Edited documentation for public release
-
-## [0.0.2] - 2026-03-03
-
-### Added
-
-- **Doctor command** — `ralphctl doctor` checks Node.js version, git, AI provider binary, data directory, project repos, and current sprint health
-- **Shell tab-completion** — `ralphctl completion install` for bash, zsh, and fish via tabtab
-- **Branch management** — `sprint start` prompts for branch strategy (keep current, auto, custom); `--branch` and `--branch-name` flags; pre-flight verification; `sprint close --create-pr` creates PRs
-- **Provider abstraction** — `config set provider claude|copilot` with adapter layer; experimental Copilot CLI support with headless execution and session ID capture
-- **Draft re-plan** — running `sprint plan` on a draft with existing tasks passes all tickets + tasks as AI context for atomic replacement
-- **Check script model** — single idempotent `checkScript` per repo replaces old `setupScript`/`verifyScript`; runs at sprint start and as a post-task gate
-- **Lifecycle hooks** — `runLifecycleHook()` abstraction in `src/ai/lifecycle.ts` with `RALPHCTL_LIFECYCLE_EVENT` env var
-- **Ecosystem detection** — `EcosystemDetector[]` registry (node, python, go, rust, gradle, maven, makefile) for check script suggestions during project setup
-- **Sprint health** — duplicate task order and pending requirements diagnostics; branch consistency checks across repos
-- **Interactive mode** — Escape key navigation, styled section titles, flat workflow section, provider config in REPL, refined/planned counts in status header, guards for unrefined/unplanned tickets
-- **Inline multiline editor** — replaced with `@inquirer/editor` and configurable editor settings via `config set editor`
-- **CI/CD** — GitHub Actions pipeline with lint, typecheck, test, format check; Dependabot; automated GitHub Release pipeline
-- **Schema sync tests** — JSON schema ↔ Zod schema validation
-
-### Changed
-
-- Renamed `claude` module to `ai` for provider-agnostic naming
-- Replaced tsup build with bash wrapper approach for CLI outside repo root
-- Default data directory changed to `~/.ralphctl` (was `ralphctl-data/`)
-- Separated repo root from data directory with smart `RALPHCTL_ROOT` handling
-- Removed `externalId` field and `--id`/`--editor` CLI flags from ticket command
-- Documentation restructured — moved to `.claude/docs/`, slimmed CLAUDE.md from 613 to 160 lines with skill-based reference material
-- Replaced raw color functions with theme helpers across all commands
-- Improved card rendering and terminal width awareness
-
-### Fixed
-
-- Sanitize session IDs and harden file operations against path traversal
-- Fixed pre-flight execution checks for security and correctness
-- Preserve error cause in re-thrown errors
-- Thread provider through `checkTaskPermissions()`
-- Branch management error handling and retry logic
-- Interactive mode duplicate quote, closed sprint status header, and dashboard duplication
-- ANSI code handling in CLI test field extraction
-- Removed redundant file reads in interactive menu context loading
-
-### Dependencies
-
-- Bumped `zod` from 3.x to 4.x
-- Bumped `@inquirer/prompts` from 7.x to 8.x
-- Bumped `@types/node`, `globals`, `ora`, `typescript-eslint`, and other dev dependencies
-
-## [0.0.1] - 2026-02-15
-
-### Added
-
-- **Project management** — register multi-repo projects with named paths
-- **Sprint lifecycle** — create, activate, close sprints with state machine enforcement (draft -> active -> closed)
-- **Ticket tracking** — add work items linked to projects, with optional external IDs
-- **Two-phase planning** — refine requirements (WHAT) then generate tasks (HOW) with human approval gates
-- **Task dependencies** — `blockedBy` references with topological sort and cycle detection
-- **Task execution** — headless, watch, session, and interactive modes via Claude CLI
-- **Parallel execution** — one task per repo concurrently, with rate limit backoff and session resume
-- **Interactive menu mode** — context-aware REPL with persistent status header and Quick Start wizard
-- **Sprint health checks** — diagnose blockers, stale tasks, and missing dependencies
-- **Requirements export** — markdown export of refined requirements
-- **Progress logging** — append-only timestamped progress log per sprint
-- **Ralph Wiggum personality** — themed UI with donut spinners, random quotes, and gradient banner

package/bin/ralphctl

@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-# Resolve symlinks so this works via npm link / pnpm link --global
-SOURCE="${BASH_SOURCE[0]}"
-while [ -L "$SOURCE" ]; do
-  DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
-  SOURCE="$(readlink "$SOURCE")"
-  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
-done
-SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
-REPO_DIR="$SCRIPT_DIR/.."
-
-export TSX_TSCONFIG_PATH="$REPO_DIR/tsconfig.json"
-exec node --import tsx "$REPO_DIR/src/cli.ts" "$@"