procedure-cli 0.1.0 → 0.1.2

package/src/components/guttered-select.tsx

@@ -1,5 +1,6 @@
 import React, { useState } from "react";
 import { Box, Text, useInput } from "ink";
+import { TextInput } from "@inkjs/ui";
 // Note: Box flexDirection="column" kept here for multi-option rendering
 
 interface Option {
@@ -62,27 +63,45 @@ interface GutteredMultiSelectProps {
   options: Option[];
   initialSelected?: string[];
   onSubmit: (values: string[]) => void;
+  /** When true, adds a "✎ Other" option that opens a free text input */
+  allowCustom?: boolean;
+  /** Placeholder shown in the custom text input */
+  customPlaceholder?: string;
 }
 
+const CUSTOM_SENTINEL = "__custom__";
+
 /**
  * Multi-select with gutter. Space to toggle, Enter to confirm.
  * Shows ● for selected, ○ for unselected. Hint at bottom.
+ * When allowCustom is true, an "Other" option lets users type custom values.
  */
-export function GutteredMultiSelect({ options, initialSelected, onSubmit }: GutteredMultiSelectProps) {
+export function GutteredMultiSelect({
+  options,
+  initialSelected,
+  onSubmit,
+  allowCustom,
+  customPlaceholder,
+}: GutteredMultiSelectProps) {
+  const allOptions = allowCustom
+    ? [...options, { label: "Other (type custom)", value: CUSTOM_SENTINEL, description: "Add your own" }]
+    : options;
+
   const [activeIndex, setActiveIndex] = useState(0);
   const [selected, setSelected] = useState<Set<string>>(
     new Set(initialSelected ?? [])
   );
+  const [phase, setPhase] = useState<"selecting" | "custom">("selecting");
 
   useInput((input, key) => {
     if (key.upArrow) {
       setActiveIndex((prev) => (prev > 0 ? prev - 1 : prev));
     } else if (key.downArrow) {
       setActiveIndex((prev) =>
-        prev < options.length - 1 ? prev + 1 : prev
+        prev < allOptions.length - 1 ? prev + 1 : prev
       );
     } else if (input === " ") {
-      const option = options[activeIndex];
+      const option = allOptions[activeIndex];
       if (option) {
         setSelected((prev) => {
           const next = new Set(prev);
@@ -95,15 +114,54 @@ export function GutteredMultiSelect({ options, initialSelected, onSubmit }: Gutt
         });
       }
     } else if (key.return) {
-      onSubmit(Array.from(selected));
+      if (selected.has(CUSTOM_SENTINEL)) {
+        setSelected((prev) => {
+          const next = new Set(prev);
+          next.delete(CUSTOM_SENTINEL);
+          return next;
+        });
+        setPhase("custom");
+      } else {
+        onSubmit(Array.from(selected));
+      }
     }
-  });
+  }, { isActive: phase === "selecting" });
+
+  if (phase === "custom") {
+    const currentSelections = Array.from(selected);
+    return (
+      <Box flexDirection="column">
+        {currentSelections.length > 0 && (
+          <Text>
+            <Text dimColor>{"│  "}</Text>
+            <Text color="green">{"Selected: "}</Text>
+            <Text>{currentSelections.join(", ")}</Text>
+          </Text>
+        )}
+        <Text>
+          <Text dimColor>{"│  "}</Text>
+          <Text bold>{"Add custom (comma-separated):"}</Text>
+        </Text>
+        <Text>
+          <Text dimColor>{"│  "}</Text>
+          <TextInput
+            placeholder={customPlaceholder ?? "Type here, press enter to confirm"}
+            onSubmit={(value) => {
+              const custom = value.split(",").map((s) => s.trim()).filter(Boolean);
+              onSubmit([...currentSelections, ...custom]);
+            }}
+          />
+        </Text>
+      </Box>
+    );
+  }
 
   return (
     <Box flexDirection="column">
-      {options.map((option, index) => {
+      {allOptions.map((option, index) => {
         const isActive = index === activeIndex;
         const isSelected = selected.has(option.value);
+        const isCustomOption = option.value === CUSTOM_SENTINEL;
         return (
           <Text key={option.value}>
             <Text dimColor>{"│  "}</Text>
@@ -113,11 +171,11 @@ export function GutteredMultiSelect({ options, initialSelected, onSubmit }: Gutt
               <Text>{"  "}</Text>
             )}
             {isSelected ? (
-              <Text color="green">{"● "}</Text>
+              <Text color={isCustomOption ? "yellow" : "green"}>{"● "}</Text>
             ) : (
               <Text dimColor>{"○ "}</Text>
             )}
-            <Text bold={isActive}>{option.label}</Text>
+            <Text bold={isActive}>{isCustomOption ? `✎ ${option.label}` : option.label}</Text>
             {option.description && (
               <Text dimColor>{" — " + option.description}</Text>
             )}
@@ -125,13 +183,22 @@ export function GutteredMultiSelect({ options, initialSelected, onSubmit }: Gutt
         );
       })}
       <Text dimColor>{"│  "}{"  ↑↓ move, space toggle, enter confirm"}</Text>
-      {selected.size > 0 && (
+      {selected.size > 0 && !selected.has(CUSTOM_SENTINEL) && (
         <Text>
           <Text dimColor>{"│  "}</Text>
           <Text color="green">{"Selected: "}</Text>
           <Text>{Array.from(selected).join(", ")}</Text>
         </Text>
       )}
+      {selected.size > 0 && selected.has(CUSTOM_SENTINEL) && (
+        <Text>
+          <Text dimColor>{"│  "}</Text>
+          <Text color="green">{"Selected: "}</Text>
+          <Text>{Array.from(selected).filter((v) => v !== CUSTOM_SENTINEL).join(", ")}</Text>
+          {selected.size > 1 && <Text dimColor>{" + custom"}</Text>}
+          {selected.size === 1 && <Text dimColor>{"custom (on confirm)"}</Text>}
+        </Text>
+      )}
     </Box>
   );
 }

package/src/lib/fs.ts

@@ -1,5 +1,6 @@
 import { mkdirSync, existsSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
+import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -16,3 +17,7 @@ export function fileExists(filePath: string): boolean {
 export function resolveTemplatePath(templateName: string): string {
   return resolve(__dirname, '..', '..', 'templates', templateName);
 }
+
+export function homeBinPath(filename: string): string {
+  return resolve(homedir(), 'bin', filename);
+}

package/src/lib/template.ts

@@ -1,9 +1,11 @@
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, chmodSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import Handlebars from 'handlebars';
-import { ensureDir, resolveTemplatePath } from './fs.js';
+import { ensureDir, resolveTemplatePath, homeBinPath } from './fs.js';
 import type { WizardAnswers } from './types.js';
 
+Handlebars.registerHelper('eq', (a: unknown, b: unknown) => a === b);
+
 export function renderTemplate(
   templatePath: string,
   data: Record<string, unknown>,
@@ -57,3 +59,103 @@ export function scaffoldAll(targetDir: string, data: WizardAnswers): void {
   ensureDir(dirname(gitignoreDest));
   writeFileSync(gitignoreDest, content, 'utf-8');
 }
+
+export interface ReleaseConflicts {
+  releaseScriptExists: boolean;
+  packageJsonHasRelease: boolean;
+  packageJsonExists: boolean;
+}
+
+export function checkReleaseConflicts(
+  projectName: string,
+  targetDir: string,
+): ReleaseConflicts {
+  const scriptPath = homeBinPath(`${projectName}-release`);
+  const pkgPath = resolve(targetDir, 'package.json');
+
+  let packageJsonExists = false;
+  let packageJsonHasRelease = false;
+
+  if (existsSync(pkgPath)) {
+    packageJsonExists = true;
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      packageJsonHasRelease = !!pkg.scripts?.['release:patch'];
+    } catch {
+      // malformed package.json — treat as no release scripts
+    }
+  }
+
+  return {
+    releaseScriptExists: existsSync(scriptPath),
+    packageJsonHasRelease,
+    packageJsonExists,
+  };
+}
+
+export interface ScaffoldReleaseResult {
+  scriptPath: string;
+  skipped: boolean;
+  reason?: string;
+}
+
+export function scaffoldRelease(
+  projectName: string,
+  data: WizardAnswers,
+): ScaffoldReleaseResult {
+  const scriptPath = homeBinPath(`${projectName}-release`);
+
+  if (existsSync(scriptPath)) {
+    return { scriptPath, skipped: true, reason: 'already exists' };
+  }
+
+  const templatePath = resolveTemplatePath('bin/release.sh.hbs');
+  const rendered = renderTemplate(templatePath, data as unknown as Record<string, unknown>);
+  ensureDir(dirname(scriptPath));
+  writeFileSync(scriptPath, rendered, 'utf-8');
+  chmodSync(scriptPath, 0o755);
+
+  return { scriptPath, skipped: false };
+}
+
+export interface PackageJsonReleaseResult {
+  created: boolean;
+  modified: boolean;
+  skipped: boolean;
+}
+
+export function ensurePackageJsonReleaseScripts(
+  targetDir: string,
+  projectName: string,
+): PackageJsonReleaseResult {
+  const pkgPath = resolve(targetDir, 'package.json');
+  const releaseScripts = {
+    'release:patch': `"$HOME/bin/${projectName}-release" patch`,
+    'release:minor': `"$HOME/bin/${projectName}-release" minor`,
+    'release:major': `"$HOME/bin/${projectName}-release" major`,
+  };
+
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      if (pkg.scripts?.['release:patch']) {
+        return { created: false, modified: false, skipped: true };
+      }
+      pkg.scripts = { ...pkg.scripts, ...releaseScripts };
+      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+      return { created: false, modified: true, skipped: false };
+    } catch {
+      // malformed — skip
+      return { created: false, modified: false, skipped: true };
+    }
+  }
+
+  const pkg = {
+    name: projectName,
+    version: '0.1.0',
+    scripts: releaseScripts,
+  };
+  ensureDir(dirname(pkgPath));
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+  return { created: true, modified: false, skipped: false };
+}

package/src/steps/generation.tsx

@@ -2,7 +2,14 @@ import React, { useEffect, useState } from "react";
 import { Text } from "ink";
 import { ConfirmInput, Spinner } from "@inkjs/ui";
 import { GutterLine } from "../components/gutter-line.js";
-import { scaffoldAll, checkConflicts } from "../lib/template.js";
+import {
+  scaffoldAll,
+  checkConflicts,
+  checkReleaseConflicts,
+  scaffoldRelease,
+  ensurePackageJsonReleaseScripts,
+} from "../lib/template.js";
+import { homeBinPath } from "../lib/fs.js";
 import type { WizardAnswers } from "../lib/types.js";
 
 interface Props {
@@ -24,13 +31,36 @@ export default function Generation({ answers, onComplete }: Props) {
     "summary" | "running" | "done" | "error"
   >("summary");
   const [errorMsg, setErrorMsg] = useState("");
+  const [releaseResult, setReleaseResult] = useState("");
 
   useEffect(() => {
     if (phase !== "running") return;
 
     try {
       const targetDir = process.cwd();
+      const projectName = answers.projectName || "untitled";
+
       scaffoldAll(targetDir, answers);
+
+      // Release script scaffolding
+      const releaseRes = scaffoldRelease(projectName, answers);
+      const pkgRes = ensurePackageJsonReleaseScripts(targetDir, projectName);
+
+      const parts: string[] = [];
+      if (releaseRes.skipped) {
+        parts.push(`~/bin/${projectName}-release (skipped, ${releaseRes.reason})`);
+      } else {
+        parts.push(`~/bin/${projectName}-release (created)`);
+      }
+      if (pkgRes.skipped) {
+        parts.push("package.json release scripts (skipped, already present)");
+      } else if (pkgRes.modified) {
+        parts.push("package.json release scripts (added)");
+      } else if (pkgRes.created) {
+        parts.push("package.json (created with release scripts)");
+      }
+      setReleaseResult(parts.join(", "));
+
       setPhase("done");
       const timer = setTimeout(() => onComplete({ generationSkipped: false }), 1500);
       return () => clearTimeout(timer);
@@ -59,6 +89,18 @@ export default function Generation({ answers, onComplete }: Props) {
       .join(", ");
 
     const conflicts = checkConflicts(process.cwd());
+    const projectName = answers.projectName || "untitled";
+    const releaseConflicts = checkReleaseConflicts(projectName, process.cwd());
+
+    const scriptDisplay = `~/bin/${projectName}-release`;
+    const scriptStatus = releaseConflicts.releaseScriptExists
+      ? "exists, will skip"
+      : "new";
+    const pkgStatus = releaseConflicts.packageJsonHasRelease
+      ? "has release scripts, will skip"
+      : releaseConflicts.packageJsonExists
+        ? "will add release scripts"
+        : "will create with release scripts";
 
     return (
       <>
@@ -114,6 +156,18 @@ export default function Generation({ answers, onComplete }: Props) {
         <GutterLine>
           <Text> </Text>
         </GutterLine>
+        <GutterLine>
+          <Text>Release setup:</Text>
+        </GutterLine>
+        <GutterLine>
+          <Text>  {scriptDisplay} → {scriptStatus}</Text>
+        </GutterLine>
+        <GutterLine>
+          <Text>  package.json → {pkgStatus}</Text>
+        </GutterLine>
+        <GutterLine>
+          <Text> </Text>
+        </GutterLine>
         <GutterLine>
           <Text>Proceed? </Text>
           <ConfirmInput onConfirm={handleConfirm} onCancel={handleCancel} />
@@ -139,8 +193,15 @@ export default function Generation({ answers, onComplete }: Props) {
   }
 
   return (
-    <GutterLine>
-      <Text color="green">All project files generated successfully.</Text>
-    </GutterLine>
+    <>
+      <GutterLine>
+        <Text color="green">All project files generated successfully.</Text>
+      </GutterLine>
+      {releaseResult && (
+        <GutterLine>
+          <Text color="green">Release: {releaseResult}</Text>
+        </GutterLine>
+      )}
+    </>
   );
 }

package/src/steps/stack-style.tsx

@@ -1,8 +1,7 @@
 import React, { useState } from "react";
 import { Text } from "ink";
-import { TextInput } from "@inkjs/ui";
 import { GutterLine } from "../components/gutter-line.js";
-import { GutteredSelect } from "../components/guttered-select.js";
+import { GutteredSelect, GutteredMultiSelect } from "../components/guttered-select.js";
 import type { WizardAnswers } from "../lib/types.js";
 
 interface Props {
@@ -10,18 +9,65 @@ interface Props {
 }
 
 type Mode = "choosing" | "quickstart" | "advanced";
-type AdvancedField = "language" | "framework" | "codeStyle";
+type AdvancedStep = "language" | "framework" | "codeStyle";
 
 const PRESET_OPTIONS = [
   { label: "TypeScript + Node.js", value: "typescript-node" },
 ];
 
-const ADVANCED_FIELDS: { key: AdvancedField; label: string }[] = [
-  { key: "language", label: "Language" },
-  { key: "framework", label: "Framework" },
-  { key: "codeStyle", label: "Code style conventions (comma-separated)" },
+const LANGUAGE_OPTIONS = [
+  { label: "TypeScript", value: "TypeScript", description: "Typed JavaScript, strict mode recommended" },
+  { label: "JavaScript", value: "JavaScript", description: "Dynamic, runs everywhere" },
+  { label: "Python", value: "Python", description: "Readable, great ecosystem for AI/ML & web" },
+  { label: "Go", value: "Go", description: "Fast compilation, built-in concurrency" },
+  { label: "Rust", value: "Rust", description: "Memory-safe systems programming" },
+  { label: "Java", value: "Java", description: "Enterprise-grade, JVM ecosystem" },
+  { label: "Ruby", value: "Ruby", description: "Developer happiness, Rails ecosystem" },
+  { label: "PHP", value: "PHP", description: "Web-native, Laravel & WordPress" },
+  { label: "Swift", value: "Swift", description: "Apple platforms, type-safe" },
+  { label: "Kotlin", value: "Kotlin", description: "Modern JVM, Android-first" },
 ];
 
+const FRAMEWORK_OPTIONS = [
+  { label: "Node.js", value: "Node.js", description: "JS/TS server runtime" },
+  { label: "React", value: "React", description: "Component-based UI library" },
+  { label: "Next.js", value: "Next.js", description: "Full-stack React framework" },
+  { label: "Vue", value: "Vue", description: "Progressive UI framework" },
+  { label: "Svelte", value: "Svelte", description: "Compile-time UI framework" },
+  { label: "Express", value: "Express", description: "Minimal Node.js web framework" },
+  { label: "Fastify", value: "Fastify", description: "Fast Node.js web framework" },
+  { label: "Django", value: "Django", description: "Batteries-included Python web" },
+  { label: "Flask", value: "Flask", description: "Lightweight Python web" },
+  { label: "Rails", value: "Rails", description: "Convention-over-config Ruby web" },
+];
+
+const CODE_STYLE_OPTIONS = [
+  { label: "Strict mode", value: "Strict mode", description: "TypeScript strict, ESLint strict" },
+  { label: "camelCase / PascalCase", value: "camelCase for variables, PascalCase for types", description: "Standard JS/TS naming" },
+  { label: "ESM imports", value: "ESM imports, no CommonJS require", description: "Modern module syntax" },
+  { label: "Import ordering", value: "stdlib → external → internal import ordering", description: "Grouped imports" },
+  { label: "Return errors, don't throw", value: "Return errors, don't throw", description: "Explicit error handling" },
+  { label: "Functional style", value: "Prefer functional patterns", description: "Pure functions, immutability" },
+  { label: "No any type", value: "No any type, use unknown", description: "Strict type safety" },
+  { label: "JSDoc comments", value: "JSDoc for public APIs", description: "Documentation standard" },
+];
+
+/** Suggest frameworks based on selected languages */
+function getFrameworkPreselect(languages: string[]): string[] {
+  const langSet = new Set(languages.map((l) => l.toLowerCase()));
+  const preselect: string[] = [];
+  if (langSet.has("typescript") || langSet.has("javascript")) {
+    preselect.push("Node.js");
+  }
+  if (langSet.has("python")) {
+    preselect.push("Django");
+  }
+  if (langSet.has("ruby")) {
+    preselect.push("Rails");
+  }
+  return preselect;
+}
+
 const PRESETS: Record<string, Partial<WizardAnswers>> = {
   "typescript-node": {
     language: "TypeScript",
@@ -41,8 +87,9 @@ const PRESETS: Record<string, Partial<WizardAnswers>> = {
 
 export default function StackStyle({ onComplete }: Props) {
   const [mode, setMode] = useState<Mode>("choosing");
-  const [advancedIndex, setAdvancedIndex] = useState(0);
-  const [answers, setAnswers] = useState<Record<string, string>>({});
+  const [advancedStep, setAdvancedStep] = useState<AdvancedStep>("language");
+  const [selectedLanguages, setSelectedLanguages] = useState<string[]>([]);
+  const [selectedFrameworks, setSelectedFrameworks] = useState<string[]>([]);
 
   if (mode === "choosing") {
     return (
@@ -81,37 +128,74 @@ export default function StackStyle({ onComplete }: Props) {
   }
 
   // Advanced mode
-  const current = ADVANCED_FIELDS[advancedIndex];
+  const advStep = advancedStep as AdvancedStep;
 
-  function handleSubmit(value: string) {
-    const next = { ...answers, [current!.key]: value };
-    setAnswers(next);
+  if (advStep === "language") {
+    return (
+      <>
+        <GutterLine>
+          <Text bold>Programming languages:</Text>
+        </GutterLine>
+        <GutteredMultiSelect
+          options={LANGUAGE_OPTIONS}
+          allowCustom
+          customPlaceholder="e.g. Elixir, Zig, C++"
+          onSubmit={(values) => {
+            setSelectedLanguages(values);
+            setAdvancedStep("framework");
+          }}
+        />
+      </>
+    );
+  }
 
-    if (advancedIndex < ADVANCED_FIELDS.length - 1) {
-      setAdvancedIndex(advancedIndex + 1);
-    } else {
-      onComplete({
-        language: next.language,
-        framework: next.framework,
-        codeStyle: (next.codeStyle || "").split(",").map((s) => s.trim()),
-      });
-    }
+  if (advStep === "framework") {
+    return (
+      <>
+        <GutterLine>
+          <Text dimColor>Languages: {selectedLanguages.join(", ")}</Text>
+        </GutterLine>
+        <GutterLine>
+          <Text bold>Frameworks:</Text>
+        </GutterLine>
+        <GutteredMultiSelect
+          options={FRAMEWORK_OPTIONS}
+          initialSelected={getFrameworkPreselect(selectedLanguages)}
+          allowCustom
+          customPlaceholder="e.g. Hono, Remix, Astro"
+          onSubmit={(values) => {
+            setSelectedFrameworks(values);
+            setAdvancedStep("codeStyle");
+          }}
+        />
+      </>
+    );
   }
 
+  // codeStyle step
   return (
     <>
-      {ADVANCED_FIELDS.slice(0, advancedIndex).map((f) => (
-        <GutterLine key={f.key}>
-          <Text dimColor>
-            {f.label}: {answers[f.key]}
-          </Text>
-        </GutterLine>
-      ))}
-
       <GutterLine>
-        <Text bold>{current!.label}: </Text>
-        <TextInput placeholder="..." onSubmit={handleSubmit} />
+        <Text dimColor>Languages: {selectedLanguages.join(", ")}</Text>
+      </GutterLine>
+      <GutterLine>
+        <Text dimColor>Frameworks: {selectedFrameworks.join(", ")}</Text>
+      </GutterLine>
+      <GutterLine>
+        <Text bold>Code style conventions:</Text>
       </GutterLine>
+      <GutteredMultiSelect
+        options={CODE_STYLE_OPTIONS}
+        allowCustom
+        customPlaceholder="e.g. tabs over spaces, max 80 chars"
+        onSubmit={(values) => {
+          onComplete({
+            language: selectedLanguages.join(", "),
+            framework: selectedFrameworks.join(", "),
+            codeStyle: values,
+          });
+        }}
+      />
     </>
   );
 }

package/templates/bin/release.sh.hbs

@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  echo "Usage: $0 [patch|minor|major]"
+  exit 1
+}
+
+if [[ "${1:-}" == "" ]]; then
+  usage
+fi
+
+BUMP="$1"
+if [[ "$BUMP" != "patch" && "$BUMP" != "minor" && "$BUMP" != "major" ]]; then
+  usage
+fi
+
+echo "==> Checking git working tree..."
+if [[ -n "$(git status --porcelain)" ]]; then
+  echo "Error: git working tree is not clean. Commit or stash changes first."
+  exit 1
+fi
+
+{{#if (eq packageManager "bun")}}
+echo "==> Running verification..."
+bun run build
+
+echo "==> Bumping version ($BUMP)..."
+npm version "$BUMP"
+
+CURRENT_BRANCH="$(git branch --show-current)"
+echo "==> Pushing branch and tags to origin/$CURRENT_BRANCH..."
+git push origin "$CURRENT_BRANCH"
+git push origin --tags
+
+echo "==> Publishing..."
+bun publish
+{{else if (eq packageManager "pnpm")}}
+echo "==> Checking npm auth..."
+if ! npm whoami >/dev/null 2>&1; then
+  echo "Error: npm is not authenticated. Run: npm login"
+  exit 1
+fi
+
+echo "==> Running verification..."
+pnpm run build
+
+echo "==> Bumping version ($BUMP)..."
+npm version "$BUMP"
+
+CURRENT_BRANCH="$(git branch --show-current)"
+echo "==> Pushing branch and tags to origin/$CURRENT_BRANCH..."
+git push origin "$CURRENT_BRANCH"
+git push origin --tags
+
+echo "==> Publishing to npm..."
+pnpm publish --access public
+{{else if (eq packageManager "yarn")}}
+echo "==> Checking npm auth..."
+if ! npm whoami >/dev/null 2>&1; then
+  echo "Error: npm is not authenticated. Run: npm login"
+  exit 1
+fi
+
+echo "==> Running verification..."
+yarn build
+
+echo "==> Bumping version ($BUMP)..."
+npm version "$BUMP"
+
+CURRENT_BRANCH="$(git branch --show-current)"
+echo "==> Pushing branch and tags to origin/$CURRENT_BRANCH..."
+git push origin "$CURRENT_BRANCH"
+git push origin --tags
+
+echo "==> Publishing to npm..."
+yarn npm publish --access public
+{{else}}
+echo "==> Checking npm auth..."
+if ! npm whoami >/dev/null 2>&1; then
+  echo "Error: npm is not authenticated. Run: npm login"
+  exit 1
+fi
+
+echo "==> Running verification..."
+npm run build
+
+echo "==> Bumping version ($BUMP)..."
+npm version "$BUMP"
+
+CURRENT_BRANCH="$(git branch --show-current)"
+echo "==> Pushing branch and tags to origin/$CURRENT_BRANCH..."
+git push origin "$CURRENT_BRANCH"
+git push origin --tags
+
+echo "==> Publishing to npm..."
+npm publish --access public
+{{/if}}
+
+NEW_VERSION="$(node -p "require('./package.json').version")"
+echo "Release complete: {{projectName}}@$NEW_VERSION"