procedure-cli 0.1.13 → 0.1.14

package/src/lib/powerline.ts

@@ -1,48 +0,0 @@
-import { readFileSync, writeFileSync, copyFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { ensureDir, fileExists, resolveTemplatePath } from './fs.js';
-
-interface ClaudeSettings {
-  statusLine?: {
-    type: string;
-    command: string;
-    padding: number;
-  };
-  [key: string]: unknown;
-}
-
-export function setupPowerline(targetDir: string): void {
-  const claudeDir = resolve(targetDir, '.claude');
-  ensureDir(claudeDir);
-
-  const settingsPath = resolve(claudeDir, 'settings.json');
-
-  let settings: ClaudeSettings = {};
-  if (fileExists(settingsPath)) {
-    try {
-      const raw = readFileSync(settingsPath, 'utf-8');
-      settings = JSON.parse(raw) as ClaudeSettings;
-    } catch {
-      // Malformed settings.json — start fresh, original is not overwritten destructively
-      settings = {};
-    }
-  }
-
-  settings.statusLine = {
-    type: 'command',
-    command:
-      'npx -y @owloops/claude-powerline@latest --config=.claude/powerline-config.json',
-    padding: 0,
-  };
-
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-
-  // Copy bundled powerline-config.json to target .claude/
-  const bundledConfig = resolve(
-    resolveTemplatePath('..'),
-    'config',
-    'powerline-config.json',
-  );
-  const destConfig = resolve(claudeDir, 'powerline-config.json');
-  copyFileSync(bundledConfig, destConfig);
-}

package/src/lib/template.ts

@@ -1,161 +0,0 @@
-import { readFileSync, writeFileSync, existsSync, chmodSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import Handlebars from 'handlebars';
-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>,
-): string {
-  const source = readFileSync(templatePath, 'utf-8');
-  const template = Handlebars.compile(source);
-  return template(data);
-}
-
-export function writeTemplate(
-  templatePath: string,
-  outputPath: string,
-  data: Record<string, unknown>,
-): void {
-  const rendered = renderTemplate(templatePath, data);
-  ensureDir(dirname(outputPath));
-  writeFileSync(outputPath, rendered, 'utf-8');
-}
-
-const TEMPLATE_MAP: Array<{ template: string; output: string }> = [
-  { template: 'CLAUDE.md.hbs', output: 'CLAUDE.md' },
-  { template: 'README.md.hbs', output: 'README.md' },
-  { template: 'docs/PRD.md.hbs', output: 'docs/PRD.md' },
-  { template: 'docs/USER-STORIES.md.hbs', output: 'docs/USER-STORIES.md' },
-  { template: '.env.example.hbs', output: '.env.example' },
-];
-
-/**
- * Check which output files already exist in the target directory.
- * Returns a list of file paths that would be overwritten.
- */
-export function checkConflicts(targetDir: string): string[] {
-  const allOutputs = [
-    ...TEMPLATE_MAP.map((t) => t.output),
-    '.gitignore',
-  ];
-  return allOutputs.filter((f) => existsSync(resolve(targetDir, f)));
-}
-
-export function scaffoldAll(targetDir: string, data: WizardAnswers): void {
-  for (const { template, output } of TEMPLATE_MAP) {
-    const templatePath = resolveTemplatePath(template);
-    const outputPath = resolve(targetDir, output);
-    writeTemplate(templatePath, outputPath, data as unknown as Record<string, unknown>);
-  }
-
-  // Copy static .gitignore (no templating needed)
-  const gitignoreSrc = resolveTemplatePath('.gitignore');
-  const gitignoreDest = resolve(targetDir, '.gitignore');
-  const content = readFileSync(gitignoreSrc, 'utf-8');
-  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/lib/types.ts

@@ -1,70 +0,0 @@
-export type StepId =
-  | 'project-info'
-  | 'stack-style'
-  | 'build-test'
-  | 'architecture'
-  | 'product-context'
-  | 'generation'
-  | 'powerline';
-
-export interface UserStoryScenario {
-  name: string;
-  given: string;
-  when: string;
-  then: string;
-}
-
-export interface UserStory {
-  title: string;
-  asA: string;
-  iWant: string;
-  soThat: string;
-  feature: string;
-  scenarios: UserStoryScenario[];
-}
-
-export interface EnvVar {
-  key: string;
-  comment: string;
-}
-
-export interface WizardAnswers {
-  // Step 1: Project Info
-  projectName: string;
-  description: string;
-  packageManager: string;
-  license: string;
-
-  // Step 2: Stack & Style
-  codeStyle: string[];
-  framework: string;
-  language: string;
-
-  // Step 3: Build & Test
-  buildCommand: string;
-  testCommand: string;
-  typecheckCommand: string;
-  lintCommand: string;
-  prCommand: string;
-
-  // Step 4: Architecture
-  architecture: string;
-  architectureNotes: string;
-
-  // Step 5: Product Context
-  problem: string;
-  users: string;
-  coreFeatures: string[];
-  nonGoals: string[];
-  techStack: string;
-  userStories: UserStory[];
-  envVars: EnvVar[];
-
-  // Step 6: Generation
-  generationSkipped: boolean;
-
-  // Step 7: Setup
-  setupPowerline: boolean;
-  setupGit: boolean;
-  setupRelease: boolean;
-}

package/src/providers/openai.ts

@@ -1,5 +0,0 @@
-import { createOpenAI } from "@ai-sdk/openai";
-
-export const openai = createOpenAI({
-  apiKey: process.env.OPENAI_API_KEY,
-});

package/src/providers/zai.ts

@@ -1,7 +0,0 @@
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-
-export const zai = createOpenAICompatible({
-  name: "zai",
-  baseURL: "https://api.z.ai/v1",
-  apiKey: process.env.ZAI_API_KEY,
-});

package/src/steps/architecture.tsx

@@ -1,72 +0,0 @@
-import React, { useState } from "react";
-import { Text } from "ink";
-import { GutterLine } from "../components/gutter-line.js";
-import { GutteredSelect } from "../components/guttered-select.js";
-import type { WizardAnswers } from "../lib/types.js";
-import { C } from "../theme.js";
-
-interface Props {
-  onComplete: (answers: Partial<WizardAnswers>) => void;
-}
-
-const ARCHITECTURE_OPTIONS = [
-  { label: "Monorepo — Multiple packages in one repository", value: "Monorepo" },
-  { label: "MVC — Model-View-Controller separation", value: "MVC" },
-  { label: "Feature folders — Co-located components, hooks, utils per feature", value: "Feature folders" },
-  { label: "Layered — Presentation > Business > Data access layers", value: "Layered" },
-  { label: "Microservices — Independent deployable services", value: "Microservices" },
-  { label: "Serverless — Function-based, event-driven architecture", value: "Serverless" },
-  { label: "Modular monolith — Single deploy, strict module boundaries", value: "Modular monolith" },
-];
-
-const ARCHITECTURE_NOTES: Record<string, string> = {
-  Monorepo:
-    "Shared packages in packages/, apps in apps/. Use workspace protocol for cross-references.",
-  MVC:
-    "Controllers handle HTTP, models handle data, views handle presentation. Keep business logic in models.",
-  "Feature folders":
-    "Each feature owns its components, hooks, utils, and tests. Shared code in shared/ or lib/.",
-  Layered:
-    "Strict dependency direction: Presentation -> Business -> Data. No skipping layers.",
-  Microservices:
-    "Each service owns its data store. Communicate via APIs or message queues. Deploy independently.",
-  Serverless:
-    "One function per endpoint. Keep functions stateless. Use managed services for state and storage.",
-  "Modular monolith":
-    "Define explicit module boundaries with public APIs. No direct cross-module database access.",
-};
-
-export default function Architecture({ onComplete }: Props) {
-  const [selected, setSelected] = useState<string | null>(null);
-
-  function handleChange(value: string) {
-    const notes = ARCHITECTURE_NOTES[value] ?? "";
-    setSelected(value);
-    // Use setTimeout to allow React to render the selection before completing
-    setTimeout(() => {
-      onComplete({ architecture: value, architectureNotes: notes });
-    }, 100);
-  }
-
-  if (selected) {
-    return (
-      <>
-        <GutterLine>
-          <Text color={C.overlay1}>Architecture: {selected}</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text color={C.overlay1}>Notes: {ARCHITECTURE_NOTES[selected]}</Text>
-        </GutterLine>
-      </>
-    );
-  }
-
-  return (
-    <>
-      <GutterLine>
-        <Text bold>Architecture pattern:</Text>
-      </GutterLine>
-      <GutteredSelect options={ARCHITECTURE_OPTIONS} onChange={handleChange} />
-    </>
-  );
-}

package/src/steps/build-test.tsx

@@ -1,114 +0,0 @@
-import React, { useState, useEffect } from "react";
-import { Text, useInput } from "ink";
-import { TextInput } from "@inkjs/ui";
-import { GutterLine } from "../components/gutter-line.js";
-import type { WizardAnswers } from "../lib/types.js";
-import { C } from "../theme.js";
-
-interface Props {
-  initialValues?: Partial<WizardAnswers>;
-  onComplete: (answers: Partial<WizardAnswers>) => void;
-}
-
-type Field =
-  | "buildCommand"
-  | "testCommand"
-  | "typecheckCommand"
-  | "lintCommand"
-  | "prCommand";
-
-const FIELDS: { key: Field; label: string; fallback: string; required: boolean }[] = [
-  { key: "buildCommand", label: "Build command", fallback: "npm run build", required: true },
-  { key: "testCommand", label: "Test command", fallback: "npm run test", required: true },
-  { key: "typecheckCommand", label: "Typecheck command", fallback: "tsc --noEmit", required: false },
-  { key: "lintCommand", label: "Lint command", fallback: "npm run lint", required: false },
-  { key: "prCommand", label: "Pre-PR command", fallback: "npm run lint && npm run test", required: false },
-];
-
-export default function BuildTest({ initialValues, onComplete }: Props) {
-  const [fieldIndex, setFieldIndex] = useState(0);
-  const [answers, setAnswers] = useState<Record<string, string>>({});
-  const [error, setError] = useState("");
-  const [liveInput, setLiveInput] = useState("");
-
-  const current = FIELDS[fieldIndex]!;
-  const preset = initialValues?.[current.key] as string | undefined;
-  const defaultVal = preset || current.fallback;
-
-  // Reset live input when navigating to a different field
-  useEffect(() => {
-    setLiveInput("");
-  }, [fieldIndex]);
-
-  useInput((input, key) => {
-    if (key.shift && key.tab && fieldIndex > 0) {
-      setFieldIndex((f) => f - 1);
-      setError("");
-    } else if (key.tab && !key.shift) {
-      const val = liveInput.trim() || answers[current.key] || defaultVal;
-      if (current.required && !val.trim()) {
-        setError(`${current.label} is required`);
-        return;
-      }
-      setError("");
-      const next = { ...answers, [current.key]: val };
-      setAnswers(next);
-      if (fieldIndex < FIELDS.length - 1) {
-        setFieldIndex((f) => f + 1);
-      } else {
-        onComplete(next as unknown as Partial<WizardAnswers>);
-      }
-    }
-  });
-
-  function handleSubmit(value: string) {
-    const val = value.trim() || defaultVal;
-    if (current.required && !val) {
-      setError(`${current.label} is required`);
-      return;
-    }
-    setError("");
-    const next = { ...answers, [current.key]: val };
-    setAnswers(next);
-    if (fieldIndex < FIELDS.length - 1) {
-      setFieldIndex(fieldIndex + 1);
-    } else {
-      onComplete(next as unknown as Partial<WizardAnswers>);
-    }
-  }
-
-  const isFirst = fieldIndex === 0;
-  const isLast = fieldIndex === FIELDS.length - 1;
-
-  return (
-    <>
-      {FIELDS.slice(0, fieldIndex).map((f) => (
-        <GutterLine key={f.key}>
-          <Text color={C.overlay1}>
-            {f.label}: {answers[f.key]}
-          </Text>
-        </GutterLine>
-      ))}
-
-      <GutterLine>
-        <Text bold>{current.label}</Text>
-        <Text color={C.overlay1}> ({defaultVal})</Text>
-        <Text bold>: </Text>
-        <TextInput placeholder={defaultVal} onChange={setLiveInput} onSubmit={handleSubmit} />
-      </GutterLine>
-
-      {error && (
-        <GutterLine>
-          <Text color={C.red}>{error}</Text>
-        </GutterLine>
-      )}
-
-      <GutterLine>
-        <Text color={C.overlay1}>
-          {!isFirst ? "Shift+Tab prev  " : ""}
-          {isLast ? "Tab / Enter confirm" : "Tab next  Enter confirm"}
-        </Text>
-      </GutterLine>
-    </>
-  );
-}

package/src/steps/generation.tsx

@@ -1,176 +0,0 @@
-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 type { WizardAnswers } from "../lib/types.js";
-import { C } from "../theme.js";
-
-interface Props {
-  answers: WizardAnswers;
-  onComplete: (partial: Partial<WizardAnswers>) => void;
-}
-
-const FILES_TO_GENERATE = [
-  "CLAUDE.md",
-  "README.md",
-  "docs/PRD.md",
-  "docs/USER-STORIES.md",
-  ".env.example",
-  ".gitignore",
-];
-
-export default function Generation({ answers, onComplete }: Props) {
-  const [phase, setPhase] = useState<"summary" | "running" | "done" | "error">("summary");
-  const [errorMsg, setErrorMsg] = useState("");
-
-  useEffect(() => {
-    if (phase !== "running") return;
-
-    try {
-      scaffoldAll(process.cwd(), answers);
-      setPhase("done");
-      const timer = setTimeout(() => onComplete({ generationSkipped: false }), 1500);
-      return () => clearTimeout(timer);
-    } catch (err) {
-      setPhase("error");
-      setErrorMsg(err instanceof Error ? err.message : String(err));
-    }
-  }, [phase]);
-
-  function handleConfirm() { setPhase("running"); }
-  function handleCancel() { onComplete({ generationSkipped: true }); }
-
-  if (phase === "summary") {
-    const conflicts = checkConflicts(process.cwd());
-    const codeStyleDisplay = answers.codeStyle.length > 0
-      ? answers.codeStyle.join(", ")
-      : "N/A";
-
-    return (
-      <>
-        {/* ── Project Info ── */}
-        <GutterLine>
-          <Text bold color={C.sapphire}>Project Info</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  Name: <Text bold>{answers.projectName || "untitled"}</Text></Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  Description: {answers.description || "N/A"}</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  Package manager: {answers.packageManager} | License: {answers.license}</Text>
-        </GutterLine>
-
-        {/* ── Stack & Style ── */}
-        <GutterLine><Text> </Text></GutterLine>
-        <GutterLine>
-          <Text bold color={C.sapphire}>Stack & Style</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  Language: {answers.language || "N/A"} | Framework: {answers.framework || "N/A"}</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  Code style: {codeStyleDisplay}</Text>
-        </GutterLine>
-
-        {/* ── Build & Test ── */}
-        <GutterLine><Text> </Text></GutterLine>
-        <GutterLine>
-          <Text bold color={C.sapphire}>Build & Test</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  Build: {answers.buildCommand || "N/A"} | Test: {answers.testCommand || "N/A"}</Text>
-        </GutterLine>
-        {(answers.typecheckCommand || answers.lintCommand) && (
-          <GutterLine>
-            <Text>  Typecheck: {answers.typecheckCommand || "N/A"} | Lint: {answers.lintCommand || "N/A"}</Text>
-          </GutterLine>
-        )}
-        {answers.prCommand && (
-          <GutterLine>
-            <Text>  PR: {answers.prCommand}</Text>
-          </GutterLine>
-        )}
-
-        {/* ── Architecture ── */}
-        <GutterLine><Text> </Text></GutterLine>
-        <GutterLine>
-          <Text bold color={C.sapphire}>Architecture</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  {answers.architecture || "N/A"}</Text>
-        </GutterLine>
-
-        {/* ── Product Context ── */}
-        <GutterLine><Text> </Text></GutterLine>
-        <GutterLine>
-          <Text bold color={C.sapphire}>Product Context</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  Problem: {answers.problem || "N/A"}</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  Users: {answers.users || "N/A"}</Text>
-        </GutterLine>
-        {answers.techStack && (
-          <GutterLine>
-            <Text>  Tech stack: {answers.techStack}</Text>
-          </GutterLine>
-        )}
-        <GutterLine>
-          <Text>  Features: {answers.coreFeatures.length > 0 ? answers.coreFeatures.join(", ") : "N/A"}</Text>
-        </GutterLine>
-        {answers.nonGoals.length > 0 && (
-          <GutterLine>
-            <Text>  Non-goals: {answers.nonGoals.join(", ")}</Text>
-          </GutterLine>
-        )}
-
-        {/* ── Files ── */}
-        <GutterLine><Text> </Text></GutterLine>
-        <GutterLine>
-          <Text bold color={C.sapphire}>Files to generate</Text>
-        </GutterLine>
-        <GutterLine>
-          <Text>  {FILES_TO_GENERATE.join(", ")}</Text>
-        </GutterLine>
-        {conflicts.length > 0 && (
-          <GutterLine>
-            <Text color={C.peach}>  ⚠ Will overwrite: {conflicts.join(", ")}</Text>
-          </GutterLine>
-        )}
-
-        {/* ── Confirm ── */}
-        <GutterLine><Text> </Text></GutterLine>
-        <GutterLine>
-          <Text>Proceed? </Text>
-          <ConfirmInput onConfirm={handleConfirm} onCancel={handleCancel} />
-        </GutterLine>
-      </>
-    );
-  }
-
-  if (phase === "running") {
-    return (
-      <GutterLine>
-        <Spinner label="Generating project files..." />
-      </GutterLine>
-    );
-  }
-
-  if (phase === "error") {
-    return (
-      <GutterLine>
-        <Text color={C.red}>Error generating files: {errorMsg}</Text>
-      </GutterLine>
-    );
-  }
-
-  return (
-    <GutterLine>
-      <Text color={C.green}>All project files generated successfully.</Text>
-    </GutterLine>
-  );
-}