@planu/cli 4.13.0 → 5.0.0

package/dist/config/version-defaults.ts

@@ -1,76 +0,0 @@
-// config/version-defaults.ts — Central registry loader for default-versions.json
-// All hardcoded versions in the codebase are sourced from this file.
-
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { join, dirname } from 'node:path';
-import type { VersionDefaults } from '../types/infrastructure.js';
-
-const FALLBACK: VersionDefaults = {
-  docker: {},
-  terraform: {},
-  npm: {},
-  jvm: {},
-  scala: {},
-  elixir: {},
-  dart: {},
-  rust: {},
-  cdn: {},
-  standards: {},
-};
-
-function loadDefaults(): VersionDefaults {
-  try {
-    const dir = dirname(fileURLToPath(import.meta.url));
-    const raw = readFileSync(join(dir, 'default-versions.json'), 'utf-8');
-    return JSON.parse(raw) as VersionDefaults;
-  } catch {
-    return FALLBACK;
-  }
-}
-
-const defaults: VersionDefaults = loadDefaults();
-
-export function getDockerTag(service: string): string {
-  return defaults.docker[service]?.tag ?? 'latest';
-}
-
-export function getTerraformVersion(resource: string): string {
-  return defaults.terraform[resource]?.version ?? '';
-}
-
-export function getNpmVersion(pkg: string): string {
-  return defaults.npm[pkg]?.version ?? 'latest';
-}
-
-export function getJvmVersion(lib: string): string {
-  return defaults.jvm[lib]?.version ?? '';
-}
-
-export function getScalaVersion(tool: string): string {
-  return defaults.scala[tool]?.version ?? '';
-}
-
-export function getElixirVersion(dep: string): string {
-  return defaults.elixir[dep]?.version ?? '';
-}
-
-export function getDartVersion(pkg: string): string {
-  return defaults.dart[pkg]?.version ?? '';
-}
-
-export function getRustVersion(crate: string): string {
-  return defaults.rust[crate]?.version ?? '';
-}
-
-export function getCdnUrl(name: string): string {
-  const entry = defaults.cdn[name];
-  if (!entry) {
-    return '';
-  }
-  return entry.baseUrl.replace('{version}', entry.version);
-}
-
-export function getStandardVersion(name: string): string {
-  return defaults.standards?.[name]?.version ?? '';
-}

package/dist/config/version.ts

@@ -1,18 +0,0 @@
-// version.ts — reads from package.json at runtime; updated by the local release flow
-
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '../../package.json');
-let version = '0.0.0';
-try {
-  const raw: unknown = JSON.parse(readFileSync(pkgPath, 'utf8'));
-  if (typeof raw === 'object' && raw !== null && 'version' in raw) {
-    version = String(raw.version);
-  }
-} catch {
-  // Fallback to unknown version on parse error
-}
-
-export const PLANU_VERSION = version;

package/dist/engine/ai-integration/gemini/settings-generator.d.ts

@@ -1,4 +0,0 @@
-import type { GeminiSettings } from '../../../types/gemini-integration.js';
-export declare function generateGeminiSettings(_projectPath: string): GeminiSettings;
-export declare function writeGeminiSettings(projectPath: string): void;
-//# sourceMappingURL=settings-generator.d.ts.map

package/dist/engine/ai-integration/gemini/settings-generator.js

@@ -1,195 +0,0 @@
-// @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
-// engine/ai-integration/gemini/settings-generator.ts — Gemini settings generator (SPEC-267)
-import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-const HOOK_SCRIPTS_DIR = '.gemini/hooks';
-// Shell scripts stored as plain strings — bash $ chars must NOT be template-interpolated
-const HOOK_SCRIPT_SESSION_START = [
-    '#!/usr/bin/env bash',
-    '# Injected by Planu — session-start.sh',
-    'BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")',
-    'SPEC=$(echo "$BRANCH" | grep -oE \'SPEC-[0-9]+\' || echo "")',
-    'if [ -n "$SPEC" ]; then',
-    '  echo "Active spec: $SPEC | Branch: $BRANCH"',
-    'else',
-    '  echo "No active spec branch. Create a spec first."',
-    'fi',
-].join('\n');
-const HOOK_SCRIPT_SESSION_END = [
-    '#!/usr/bin/env bash',
-    '# session-end.sh — optionally auto-commit planu/ changes',
-    'if [ "$PLANU_ENABLE_AUTOCOMMIT" != "true" ]; then',
-    '  exit 0',
-    'fi',
-    'if git diff --quiet HEAD -- planu/ 2>/dev/null; then',
-    '  exit 0',
-    'fi',
-    'git add planu/specs/ planu/conventions.json && git commit -m "chore: auto-save planu session state" --no-verify 2>/dev/null || true',
-].join('\n');
-const HOOK_SCRIPT_BEFORE_AGENT = [
-    '#!/usr/bin/env bash',
-    '# before-agent.sh — inject active spec context',
-    'BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")',
-    'SPEC=$(echo "$BRANCH" | grep -oE \'SPEC-[0-9]+\' || echo "")',
-    '[ -n "$SPEC" ] && echo "Spec in scope: $SPEC" || echo "No spec branch active."',
-].join('\n');
-const HOOK_SCRIPT_NOOP = [
-    '#!/usr/bin/env bash',
-    '# noop.sh — placeholder for future hooks',
-    'exit 0',
-].join('\n');
-const HOOK_SCRIPT_BEFORE_TOOL_SELECTION = [
-    '#!/usr/bin/env bash',
-    '# before-tool-selection.sh — warn if no spec branch for write ops',
-    'BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")',
-    'if echo "$BRANCH" | grep -qE \'feat/SPEC-|fix/SPEC-\'; then',
-    '  exit 0',
-    'fi',
-    'echo "WARNING: No spec branch active. Writing code without a spec is discouraged."',
-].join('\n');
-const HOOK_SCRIPT_BEFORE_TOOL = [
-    '#!/usr/bin/env bash',
-    '# before-tool.sh — scan for destructive operations',
-    'TOOL_NAME="${TOOL_NAME:-}"',
-    'if echo "$TOOL_NAME" | grep -qiE \'delete|remove|drop|truncate\'; then',
-    '  echo "WARNING: Destructive operation detected: $TOOL_NAME"',
-    'fi',
-].join('\n');
-const HOOK_SCRIPT_AFTER_TOOL = [
-    '#!/usr/bin/env bash',
-    '# after-tool.sh — verify spec when modifying src/',
-    'TOOL_INPUT="${TOOL_INPUT:-}"',
-    'if echo "$TOOL_INPUT" | grep -q \'src/\'; then',
-    '  BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")',
-    '  if ! echo "$BRANCH" | grep -qE \'feat/SPEC-|fix/SPEC-\'; then',
-    '    echo "NOTICE: src/ modified outside a spec branch."',
-    '  fi',
-    'fi',
-].join('\n');
-const HOOK_SCRIPT_PRE_COMPRESS = [
-    '#!/usr/bin/env bash',
-    '# pre-compress.sh — trigger session_checkpoint',
-    'echo "Session checkpoint triggered before context compression."',
-].join('\n');
-const HOOK_SCRIPT_NOTIFICATION = [
-    '#!/usr/bin/env bash',
-    '# notification.sh — show approved specs queue when idle',
-    'echo "Planu queue: run \'list_specs --status approved\' to see pending specs."',
-].join('\n');
-function buildHooks() {
-    return [
-        {
-            event: 'SessionStart',
-            command: `bash ${HOOK_SCRIPTS_DIR}/session-start.sh`,
-            timeout: 5000,
-        },
-        {
-            event: 'SessionEnd',
-            command: `bash ${HOOK_SCRIPTS_DIR}/session-end.sh`,
-            timeout: 10000,
-        },
-        {
-            event: 'BeforeAgent',
-            command: `bash ${HOOK_SCRIPTS_DIR}/before-agent.sh`,
-            timeout: 5000,
-        },
-        {
-            event: 'AfterAgent',
-            command: `bash ${HOOK_SCRIPTS_DIR}/noop.sh`,
-            timeout: 1000,
-        },
-        {
-            event: 'BeforeModel',
-            command: `bash ${HOOK_SCRIPTS_DIR}/noop.sh`,
-            timeout: 1000,
-        },
-        {
-            event: 'AfterModel',
-            command: `bash ${HOOK_SCRIPTS_DIR}/noop.sh`,
-            timeout: 1000,
-        },
-        {
-            event: 'BeforeToolSelection',
-            command: `bash ${HOOK_SCRIPTS_DIR}/before-tool-selection.sh`,
-            timeout: 3000,
-        },
-        {
-            event: 'BeforeTool',
-            command: `bash ${HOOK_SCRIPTS_DIR}/before-tool.sh`,
-            timeout: 3000,
-        },
-        {
-            event: 'AfterTool',
-            command: `bash ${HOOK_SCRIPTS_DIR}/after-tool.sh`,
-            timeout: 3000,
-        },
-        {
-            event: 'PreCompress',
-            command: `bash ${HOOK_SCRIPTS_DIR}/pre-compress.sh`,
-            timeout: 10000,
-        },
-        {
-            event: 'Notification',
-            command: `bash ${HOOK_SCRIPTS_DIR}/notification.sh`,
-            timeout: 3000,
-        },
-    ];
-}
-function buildHookScripts() {
-    return {
-        'session-start.sh': HOOK_SCRIPT_SESSION_START,
-        'session-end.sh': HOOK_SCRIPT_SESSION_END,
-        'before-agent.sh': HOOK_SCRIPT_BEFORE_AGENT,
-        'noop.sh': HOOK_SCRIPT_NOOP,
-        'before-tool-selection.sh': HOOK_SCRIPT_BEFORE_TOOL_SELECTION,
-        'before-tool.sh': HOOK_SCRIPT_BEFORE_TOOL,
-        'after-tool.sh': HOOK_SCRIPT_AFTER_TOOL,
-        'pre-compress.sh': HOOK_SCRIPT_PRE_COMPRESS,
-        'notification.sh': HOOK_SCRIPT_NOTIFICATION,
-    };
-}
-export function generateGeminiSettings(_projectPath) {
-    return {
-        hooks: buildHooks(),
-    };
-}
-export function writeGeminiSettings(projectPath) {
-    const geminiDir = join(projectPath, '.gemini');
-    const hooksDir = join(projectPath, HOOK_SCRIPTS_DIR);
-    /* v8 ignore start */
-    if (!existsSync(geminiDir)) {
-        mkdirSync(geminiDir, { recursive: true });
-    }
-    if (!existsSync(hooksDir)) {
-        mkdirSync(hooksDir, { recursive: true });
-    }
-    /* v8 ignore stop */
-    const settingsPath = join(geminiDir, 'settings.json');
-    const settings = generateGeminiSettings(projectPath);
-    let existing = {};
-    /* v8 ignore start */
-    if (existsSync(settingsPath)) {
-        try {
-            existing = JSON.parse(readFileSync(settingsPath, 'utf8'));
-        }
-        catch {
-            // ignore malformed JSON — overwrite
-        }
-    }
-    /* v8 ignore stop */
-    const merged = {
-        ...existing,
-        hooks: settings.hooks,
-    };
-    writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
-    const scripts = buildHookScripts();
-    for (const [filename, content] of Object.entries(scripts)) {
-        const scriptPath = join(hooksDir, filename);
-        /* v8 ignore start */
-        if (!existsSync(scriptPath)) {
-            writeFileSync(scriptPath, content, { encoding: 'utf8', mode: 0o755 });
-        }
-        /* v8 ignore stop */
-    }
-}
-//# sourceMappingURL=settings-generator.js.map

package/dist/engine/ai-integration/kiro/hooks-generator.d.ts

@@ -1,6 +0,0 @@
-import type { KiroHookDefinition } from '../../../types/kiro-integration.js';
-/** Returns the standard set of Kiro hooks for Planu SDD workflow. */
-export declare function generateKiroHooks(): KiroHookDefinition[];
-/** Writes .kiro/hooks/planu-*.yaml files to the given project path */
-export declare function writeKiroHooks(projectPath: string): void;
-//# sourceMappingURL=hooks-generator.d.ts.map

package/dist/engine/ai-integration/kiro/hooks-generator.js

@@ -1,75 +0,0 @@
-// engine/ai-integration/kiro/hooks-generator.ts — Kiro hooks generator (SPEC-270)
-import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-const PROMPT_INJECT_SCRIPT = [
-    'SPEC=$(planu list --status=approved --compact 2>/dev/null | head -5 || echo "No approved specs");',
-    'BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown");',
-    'echo "=== Planu Context ===";',
-    'echo "Branch: $BRANCH";',
-    'echo "Approved specs: $SPEC"',
-].join(' ');
-const POST_TOOL_SCRIPT = [
-    'if echo "$KIRO_TOOL_NAME" | grep -qE "write|edit|create"; then',
-    '  if echo "$KIRO_TOOL_PATH" | grep -qE "^src/"; then',
-    '    planu validate --quick 2>/dev/null || echo "Reminder: validate spec compliance after editing src/";',
-    '  fi;',
-    'fi',
-].join(' ');
-const STOP_SCRIPT = [
-    'planu session_checkpoint --auto 2>/dev/null;',
-    'if [ -d "planu/" ]; then',
-    '  if [ "$PLANU_ENABLE_AUTOCOMMIT" != "true" ]; then exit 0; fi;',
-    '  git add planu/specs/ planu/conventions.json 2>/dev/null;',
-    '  git diff --staged --quiet || git commit -m "chore: auto-save planu state [kiro]" 2>/dev/null;',
-    'fi',
-].join(' ');
-/** Returns the standard set of Kiro hooks for Planu SDD workflow. */
-export function generateKiroHooks() {
-    return [
-        {
-            id: 'planu-prompt-inject',
-            event: 'userPromptSubmit',
-            description: 'Inject active spec context into every Kiro prompt',
-            script: PROMPT_INJECT_SCRIPT,
-        },
-        {
-            id: 'planu-post-tool',
-            event: 'postToolUse',
-            description: 'Auto-validate spec compliance after file writes to src/',
-            script: POST_TOOL_SCRIPT,
-        },
-        {
-            id: 'planu-stop',
-            event: 'stop',
-            description: 'Save session checkpoint and optionally auto-commit planu state on session end',
-            script: STOP_SCRIPT,
-        },
-    ];
-}
-function buildHookYaml(hook) {
-    const lines = [
-        `id: ${hook.id}`,
-        `event: ${hook.event}`,
-        `description: "${hook.description}"`,
-        'script: |',
-    ];
-    for (const line of hook.script.split(' ')) {
-        lines.push(`  ${line}`);
-    }
-    return lines.join('\n');
-}
-/** Writes .kiro/hooks/planu-*.yaml files to the given project path */
-export function writeKiroHooks(projectPath) {
-    const hooksDir = join(projectPath, '.kiro', 'hooks');
-    /* v8 ignore start */
-    if (!existsSync(hooksDir)) {
-        mkdirSync(hooksDir, { recursive: true });
-    }
-    /* v8 ignore stop */
-    const hooks = generateKiroHooks();
-    for (const hook of hooks) {
-        const yaml = buildHookYaml(hook);
-        writeFileSync(join(hooksDir, `${hook.id}.yaml`), yaml + '\n', 'utf8');
-    }
-}
-//# sourceMappingURL=hooks-generator.js.map

package/dist/engine/hooks/full-spectrum-generator.d.ts

@@ -1,32 +0,0 @@
-import type { FullSpectrumHookConfig, HookScript } from '../../types/hooks-advanced.js';
-/**
- * Generates the Stop hook script. Planu housekeeping is opt-in so generated
- * hooks cannot silently stage or commit user branches.
- */
-export declare function generateStopHookScript(projectPath: string): string;
-/**
- * Generates the PreCompact hook script — queues a session_checkpoint action.
- */
-export declare function generatePreCompactHookScript(): string;
-/**
- * Generates the UserPromptSubmit hook script — injects active spec context.
- */
-export declare function generateUserPromptSubmitHookScript(): string;
-/**
- * Generates the Notification hook script — shown when Claude is idle.
- */
-export declare function generateNotificationHookScript(): string;
-/**
- * Generates WorktreeCreate and WorktreeRemove hook scripts.
- */
-export declare function generateWorktreeHookScripts(): {
-    create: string;
-    remove: string;
-};
-/**
- * Generates all requested hook scripts based on the supplied config.
- * Returns an array of HookScript objects, one per enabled hook type.
- * The projectPath is used only for the Stop hook script.
- */
-export declare function generateFullSpectrumHooks(config: FullSpectrumHookConfig, projectPath?: string): HookScript[];
-//# sourceMappingURL=full-spectrum-generator.d.ts.map

package/dist/engine/hooks/full-spectrum-generator.js

@@ -1,117 +0,0 @@
-// engine/hooks/full-spectrum-generator.ts — Full-spectrum Claude Code hook generator (SPEC-265)
-// ---------------------------------------------------------------------------
-// Individual script builders
-// ---------------------------------------------------------------------------
-/**
- * Generates the Stop hook script. Planu housekeeping is opt-in so generated
- * hooks cannot silently stage or commit user branches.
- */
-export function generateStopHookScript(projectPath) {
-    return `#!/bin/bash
-# Optionally auto-commit planu/ if explicitly enabled (Planu Stop hook)
-cd "${projectPath}"
-if [ "$PLANU_ENABLE_AUTOCOMMIT" != "true" ]; then exit 0; fi
-if git diff --quiet planu/ 2>/dev/null; then exit 0; fi
-git add planu/specs/ planu/conventions.json && git commit -m "chore(planu): auto-commit session state [skip ci]" --no-verify
-`;
-}
-/**
- * Generates the PreCompact hook script — queues a session_checkpoint action.
- */
-export function generatePreCompactHookScript() {
-    return `#!/bin/bash
-# Queue session_checkpoint before context compression (Planu PreCompact hook)
-echo '{"tool":"session_checkpoint","note":"auto-checkpoint before context compression"}' >> /tmp/planu-pending-actions.json
-`;
-}
-/**
- * Generates the UserPromptSubmit hook script — injects active spec context.
- */
-export function generateUserPromptSubmitHookScript() {
-    return `#!/bin/bash
-# Inject active spec context on each prompt (Planu UserPromptSubmit hook)
-BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
-SPEC_ID=$(echo "$BRANCH" | grep -oE 'SPEC-[0-9]+' | head -1)
-if [ -n "$SPEC_ID" ]; then
-  echo "## Active spec: $SPEC_ID | Branch: $BRANCH"
-fi
-`;
-}
-/**
- * Generates the Notification hook script — shown when Claude is idle.
- */
-export function generateNotificationHookScript() {
-    return `#!/bin/bash
-# Show pending approved specs when Claude is idle (Planu Notification hook)
-# Non-blocking: only outputs if there are pending specs
-true
-`;
-}
-/**
- * Generates WorktreeCreate and WorktreeRemove hook scripts.
- */
-export function generateWorktreeHookScripts() {
-    const create = `#!/bin/bash
-# Log worktree creation in shared-context (Planu WorktreeCreate hook)
-echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] Worktree created: $CLAUDE_WORKTREE_PATH" >> .claude/shared-context.md 2>/dev/null || true
-`;
-    const remove = `#!/bin/bash
-# Log worktree removal in shared-context (Planu WorktreeRemove hook)
-echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] Worktree removed: $CLAUDE_WORKTREE_PATH" >> .claude/shared-context.md 2>/dev/null || true
-`;
-    return { create, remove };
-}
-// ---------------------------------------------------------------------------
-// Public aggregator
-// ---------------------------------------------------------------------------
-/**
- * Generates all requested hook scripts based on the supplied config.
- * Returns an array of HookScript objects, one per enabled hook type.
- * The projectPath is used only for the Stop hook script.
- */
-export function generateFullSpectrumHooks(config, projectPath = '$CLAUDE_PROJECT_PATH') {
-    const scripts = [];
-    if (config.stopHook) {
-        scripts.push({
-            eventType: 'Stop',
-            scriptContent: generateStopHookScript(projectPath),
-            description: 'Optionally auto-commits planu/ changes at session end when enabled.',
-        });
-    }
-    if (config.preCompactHook) {
-        scripts.push({
-            eventType: 'PreCompact',
-            scriptContent: generatePreCompactHookScript(),
-            description: 'Queues a session_checkpoint before context compression.',
-        });
-    }
-    if (config.userPromptSubmitHook) {
-        scripts.push({
-            eventType: 'UserPromptSubmit',
-            scriptContent: generateUserPromptSubmitHookScript(),
-            description: 'Injects active spec/branch context into each prompt.',
-        });
-    }
-    if (config.notificationHook) {
-        scripts.push({
-            eventType: 'Notification',
-            scriptContent: generateNotificationHookScript(),
-            description: 'Shows pending approved specs when Claude is idle.',
-        });
-    }
-    if (config.worktreeHooks) {
-        const { create, remove } = generateWorktreeHookScripts();
-        scripts.push({
-            eventType: 'WorktreeCreate',
-            scriptContent: create,
-            description: 'Logs worktree creation in .claude/shared-context.md.',
-        });
-        scripts.push({
-            eventType: 'WorktreeRemove',
-            scriptContent: remove,
-            description: 'Logs worktree removal in .claude/shared-context.md.',
-        });
-    }
-    return scripts;
-}
-//# sourceMappingURL=full-spectrum-generator.js.map

package/dist/engine/license-validator/config-loader.d.ts

@@ -1,5 +0,0 @@
-import type { LicensePlanConfig } from '../../types/index.js';
-export declare function loadLicensePlans(): LicensePlanConfig;
-/** Reset cache — used in tests. */
-export declare function resetPlanCache(): void;
-//# sourceMappingURL=config-loader.d.ts.map

package/dist/engine/license-validator/config-loader.js

@@ -1,16 +0,0 @@
-// engine/license-validator/config-loader.ts — Loads and caches license-plans.json config.
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-let cached = null;
-export function loadLicensePlans() {
-    if (cached) {
-        return cached;
-    }
-    cached = require('../../config/license-plans.json');
-    return cached;
-}
-/** Reset cache — used in tests. */
-export function resetPlanCache() {
-    cached = null;
-}
-//# sourceMappingURL=config-loader.js.map

package/dist/engine/license-validator/core.d.ts

@@ -1,15 +0,0 @@
-import type { PricingTier, LicenseState, LicenseCheckResult, TierLimits } from '../../types/index.js';
-export declare function resolveCurrentTier(state: LicenseState | null): PricingTier;
-export declare function variantToTier(variantName: string): PricingTier;
-/** Returns true if the promotional open-access window is currently active. */
-export declare function isOpenAccessActive(): boolean;
-export declare function isToolAllowed(toolName: string, tier: PricingTier, trialActive?: boolean): boolean;
-export declare function checkToolAccess(toolName: string, tier: PricingTier, context?: {
-    trialActive?: boolean;
-    trialDaysRemaining?: number;
-}): LicenseCheckResult;
-export declare function getTierLimits(tier: PricingTier): TierLimits;
-export declare function checkLimits(tier: PricingTier, currentCount: number, limitType: 'maxProjects' | 'maxActiveSpecs'): LicenseCheckResult;
-export declare function isValidationFresh(state: LicenseState): boolean;
-export declare function isInGracePeriod(state: LicenseState): boolean;
-//# sourceMappingURL=core.d.ts.map