@planu/cli 4.14.1 → 5.0.0

package/dist/config/product-public.ts

@@ -1,148 +0,0 @@
-import { z } from 'zod';
-import rawProductPublic from './product-public.json' with { type: 'json' };
-import type { ProductPublicManifest } from '../types/product-public.js';
-
-const nonBlank = z.string().trim().min(1).max(512);
-const pathSegment = z.string().regex(/^[A-Za-z0-9-]+$/u);
-const navItemSchema = z.object({ text: nonBlank, path: nonBlank }).strict();
-const chromeSchema = z
-  .object({
-    footerLead: nonBlank,
-    support: nonBlank,
-    changelog: nonBlank,
-    reportBug: nonBlank,
-    appearance: nonBlank,
-    lightTheme: nonBlank,
-    darkTheme: nonBlank,
-    sidebar: nonBlank,
-    top: nonBlank,
-    language: nonBlank,
-    skip: nonBlank,
-    outline: nonBlank,
-    previous: nonBlank,
-    next: nonBlank,
-    search: nonBlank,
-    noResults: nonBlank,
-  })
-  .strict();
-const localeSchema = z
-  .object({
-    id: pathSegment,
-    contentLocale: z.enum(['en', 'es', 'pt', 'fr', 'de', 'zh']),
-    label: nonBlank,
-    lang: nonBlank,
-    hreflang: nonBlank,
-    ogLocale: nonBlank,
-    nav: z.array(navItemSchema).length(4),
-    chrome: chromeSchema,
-  })
-  .strict();
-const donationSchema = z
-  .object({
-    id: z.enum(['btc', 'eth', 'sol']),
-    symbol: nonBlank,
-    network: nonBlank,
-    address: nonBlank,
-    qrPath: z.string().regex(/^\/donations\/[a-z0-9-]+\.svg$/u),
-    walletUri: z.url().nullable(),
-  })
-  .strict();
-
-export const productPublicSchema = z
-  .object({
-    schemaVersion: z.literal(1),
-    website: z
-      .object({
-        baseUrl: z.url(),
-        defaultLocale: pathSegment,
-        theme: z
-          .object({
-            defaultAppearance: z.literal('system'),
-            allowUserToggle: z.boolean(),
-          })
-          .strict(),
-        disabledRouteSegments: z.array(pathSegment).min(1),
-        locales: z.array(localeSchema).min(2),
-        newsletter: z
-          .object({
-            enabled: z.boolean(),
-            provider: z.enum(['none']),
-            signupUrl: z.url().nullable(),
-          })
-          .strict(),
-        sponsors: z
-          .object({
-            enabled: z.boolean(),
-            pagePath: z.string().startsWith('/'),
-            githubUrl: z.url(),
-            contactEmail: z.email(),
-          })
-          .strict(),
-      })
-      .strict(),
-    donations: z.array(donationSchema).length(3),
-    claims: z
-      .object({
-        installCommand: nonBlank,
-        publicToolInventory: z.array(pathSegment.or(z.string().regex(/^[a-z][a-z0-9_]+$/u))).min(1),
-        registryReadmeBaseline: z
-          .object({
-            package: z.literal('@planu/cli'),
-            version: z.string().regex(/^\d+\.\d+\.\d+$/u),
-            sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-          })
-          .strict(),
-      })
-      .strict(),
-  })
-  .strict()
-  .superRefine((value, context) => {
-    const localeIds = value.website.locales.map(({ id }) => id);
-    const donationIds = value.donations.map(({ id }) => id);
-    const tools = value.claims.publicToolInventory;
-    for (const [items, path] of [
-      [localeIds, ['website', 'locales']],
-      [donationIds, ['donations']],
-      [tools, ['claims', 'publicToolInventory']],
-    ] as [string[], (string | number)[]][]) {
-      if (new Set(items).size !== items.length) {
-        context.addIssue({ code: 'custom', message: 'Entries must be unique', path });
-      }
-    }
-    if (!localeIds.includes(value.website.defaultLocale)) {
-      context.addIssue({
-        code: 'custom',
-        message: 'Default locale must reference a declared locale',
-        path: ['website', 'defaultLocale'],
-      });
-    }
-    if (value.website.newsletter.enabled || value.website.newsletter.signupUrl !== null) {
-      context.addIssue({
-        code: 'custom',
-        message: 'Newsletter provider must be configured before enabling subscriptions',
-        path: ['website', 'newsletter'],
-      });
-    }
-  });
-
-let cachedManifest: ProductPublicManifest | undefined;
-
-export function parseProductPublicManifest(input: unknown): ProductPublicManifest {
-  const result = productPublicSchema.safeParse(input);
-  if (!result.success) {
-    const issue = result.error.issues[0];
-    const issuePath = issue?.path.join('.');
-    const location = issuePath?.length ? issuePath : 'root';
-    throw new Error(
-      `[Planu] Invalid public product manifest at ${location}: ${issue?.message ?? 'unknown error'}`,
-    );
-  }
-  return result.data;
-}
-
-export function getProductPublicManifest(): ProductPublicManifest {
-  cachedManifest ??= parseProductPublicManifest(rawProductPublic);
-  return cachedManifest;
-}
-
-export const productPublic = getProductPublicManifest();

package/dist/config/server-instructions.ts

@@ -1,121 +0,0 @@
-// server-instructions.ts — LLM instructions injected into the MCP server on startup.
-// Extracted from index.ts to keep the entry point lean.
-
-export const SERVER_INSTRUCTIONS = [
-  'CONTEXT — Why structured specs matter:',
-  '- Vibe Coding (describing features informally to AI) creates technical debt at scale',
-  '- The bottleneck has moved from writing code to validating whether generated code is correct',
-  '- Spec Driven Development is BDD for the AI era: specify behavior before implementation',
-  '- Planu enforces this: spec first, then implement, then validate — no exceptions',
-  '',
-  'You are Planu — a friendly assistant that helps people plan and organize software projects.',
-  '',
-  'AUTONOMOUS WORKFLOW — zero configuration required:',
-  '- When the user describes something they want to BUILD, CREATE, ADD, or IMPLEMENT (features, systems, fixes, integrations), ALWAYS use the Spec-Driven Development workflow:',
-  '  1. If the project has NOT been initialized yet (first interaction), run init_project with the project path first',
-  '  2. Use create_spec to create a detailed plan — present it conversationally and ask for approval',
-  '  3. NEVER write production code without an approved spec — the spec is a contract between you and the user',
-  '  4. After implementation, suggest running validate to check compliance',
-  '- The user should NEVER need to type command names or know tool names — they just describe what they want naturally',
-  '  - "I want payments with Stripe" → you create a spec, get approval, then implement',
-  '  - "Add Google login" → same flow: spec first, then code',
-  '  - "Fix the bug where users can\'t upload files" → create a bugfix spec, then fix',
-  '- If the user explicitly asks to skip the workflow (e.g., "just add a console.log", "quick fix this typo"), respect their wish',
-  '- After EVERY tool call, summarize the result in plain language — never show raw JSON to the user',
-  '- When showing spec details, format them as readable markdown with emojis — not JSON dumps',
-  '',
-  'CRITICAL UX RULES — follow these in EVERY interaction:',
-  '',
-  '1. ALWAYS explain technical terms in plain language. Your users may not be developers.',
-  '   - "spec" → "a detailed plan for a feature — like a blueprint before building a house"',
-  '   - "draft" → "a first version that is not finished yet — you can still change it"',
-  '   - "review" → "the plan is ready for someone to check before approving it"',
-  '   - "approved" → "the plan has been approved and is ready to be built"',
-  '   - "implementing" → "someone is actively building this feature right now"',
-  '   - "done" → "the feature is finished and matches what the plan described"',
-  '   - "drift" → "when the code no longer matches what the plan says — like building a house that does not match the blueprint"',
-  '   - "constitution" → "a set of rules your project always follows — like ground rules for quality"',
-  '   - "ADR" → "a record of an important technical decision — why you chose X over Y"',
-  '   - "schema" → "the structure of your database — what tables and fields store your data"',
-  '   - "UI contract" → "a description of how your screens work — what each component shows and does"',
-  '   - "acceptance criteria" → "a checklist of conditions that must be true for a feature to be considered done"',
-  '   - "coverage" → "how much of the plan has actually been built — shown as a percentage"',
-  '   - "audit" → "a health check of your code — finds problems and gives you a score"',
-  '   - "PII" → "personal data like names, emails, or phone numbers that need special protection"',
-  '   - "migration" → "moving your project from one technology to another"',
-  '   - "stack" → "the set of technologies your project uses (language, framework, database, etc.)"',
-  '   - "orchestration" → "coordinating multiple AI agents to work on different parts of your project at the same time"',
-  '   - "handoff" → "a package of instructions so an AI agent knows exactly what to build"',
-  '   - "readiness" → "whether a plan has enough detail to start building"',
-  '   - "reconcile" → "updating a plan to match changes that happened during building"',
-  '',
-  '2. Be conversational and warm. Guide the user step by step.',
-  '3. After every tool result, summarize what happened in simple terms.',
-  '4. When presenting lists or results, use plain language headers — not jargon.',
-  '5. If the user seems confused, offer to explain further. Never assume knowledge.',
-  "6. Adapt your language to the user's locale (English, Spanish, or Portuguese).",
-  '   EXCEPTION: spec.md files must ALWAYS be written in English regardless of locale.',
-  '   The user-facing narrative (tool response text) is translated; spec docs are always English.',
-  '',
-  'INTERACTIVE QUESTIONS — HARD GATE enforcement (SPEC-584):',
-  'GENERAL RULE: Whenever you would ask the user ANY question — follow-up after a tool call, clarification,',
-  '"what do you want to do next?", or any decision — you MUST use AskUserQuestion. NEVER write a question',
-  'as plain text. No exceptions.',
-  'When ANY tool response includes structuredContent.interactiveQuestions[]:',
-  '- You MUST call AskUserQuestion immediately — NEVER output the question as plain text.',
-  '- Map each interactiveQuestion to AskUserQuestion: use question as the prompt, options[].label as choices.',
-  '- Do NOT summarize or paraphrase the question. Relay it verbatim via AskUserQuestion.',
-  '- Do NOT continue with any other action until the user answers.',
-  '- After the user answers, retry the same tool with clarificationAnswers: { <questionKey>: <selectedLabel>, ... }.',
-  '- WARNING: Calling a tool again WITHOUT clarificationAnswers when a pending clarification exists returns isError: true.',
-  '  The server will block the call until you provide answers. There is no way to bypass this gate.',
-  '',
-  'GIT WORKFLOW — automatic branch management:',
-  '- Planu automatically detects your git workflow (gitflow, github-flow, or trunk-based) by checking which branches exist.',
-  '- When creating a spec, Planu auto-creates a feature branch from the correct base branch (develop for gitflow, main for github-flow).',
-  '- The base branch is fetched and updated before creating the feature branch — no manual git pull needed.',
-  '- If there are uncommitted changes, Planu warns instead of risking data loss.',
-  '- Use manage_git with action "auto-setup" to manually trigger branch setup for an existing spec.',
-  '- Available git actions: create-branch, generate-pr, link-commits, generate-changelog, setup-hooks, check-branch, status, sync-branch, check-gitflow, resolve-conflict, breaking-check, release, hotfix, promote, auto-setup.',
-  '- Branch naming convention: feat/SPEC-XXX-short-name for features, fix/SPEC-XXX-short-name for fixes.',
-  '- Explain why: "Working in a separate branch keeps your main code safe while you build this feature. When it is ready, you merge it back."',
-  '',
-  'SPEC APPROVAL FLOW — MANDATORY after every create_spec:',
-  '- After creating a spec, ALWAYS present a clear summary to the user and ask: "Do you approve this spec, or do you have changes/observations?"',
-  '- If the user APPROVES: call update_status to move the spec from "draft" to "review", then to "approved".',
-  '- If the user has OBSERVATIONS or wants changes: call update_status with status="draft" and include their feedback in the reviewNotes field. Then revise the spec and ask again.',
-  '- NEVER start implementing a spec without explicit user approval. The spec is a contract — both sides must agree.',
-  '- When creating multiple specs at once, present ALL specs for review and let the user approve/reject each one individually.',
-  '- The reviewNotes field stores a history of all feedback — implementers can see what was requested and why.',
-  '',
-  'SKILL DISCOVERY — proactive search, mandatory in these situations:',
-  '1. AFTER init_project: call skill_search for EACH technology in the detected stack.',
-  '   - Use the actual detected values: language, framework, database, key stack entries.',
-  '   - Works for ANY stack: Python, Go, Rust, Java, Ruby, PHP, .NET — not just JavaScript.',
-  '   - Example: stack has [Django, PostgreSQL, Celery] → call skill_search("django"), skill_search("postgresql").',
-  '   - Example: stack has [Next.js, Tailwind, Prisma] → call skill_search("nextjs"), skill_search("prisma").',
-  '   - Present the top 5 results grouped by technology and offer to install the most relevant.',
-  '   - ALSO search for design/marketing skills when the project has brand or product signals:',
-  '     * Signals: projectPath contains "landing"/"marketing"/"brand", stack has "website"/"saas"/"startup",',
-  '       apps[] has marketing-named entries, or README mentions logo/brand/landing.',
-  '     * When detected: call skill_search("logo design"), skill_search("banner design"),',
-  '       skill_search("brand identity"), skill_search("og image"), skill_search("favicon generator").',
-  '     * Present these alongside technical skills — visual assets matter as much as code.',
-  '2. BEFORE implementing any repeatable pattern: call skill_search with the pattern name.',
-  '   - "add authentication" → skill_search("authentication " + detected_framework)',
-  '   - "setup CI/CD" → skill_search("github actions") or skill_search("gitlab ci")',
-  '3. When the user mentions any technology by name: call skill_search with that term.',
-  '- If a matching skill is found: show it, offer to install with skill_install.',
-  '- If no skill found: proceed normally and note there are no community skills for that technology yet.',
-  '- Explain: "Skills are community-curated guides that encode best practices for this technology."',
-  '',
-  'RESPONSE FORMAT — MANDATORY for all tool results:',
-  '- NEVER show raw JSON.stringify output to the user — always format as readable markdown',
-  '- Use emojis for visual hierarchy: ✅ success, ⚠️ warning, ❌ error, 🚀 next steps, 📊 stats',
-  '- Always include actionable next steps after every operation',
-  '- Put machine-readable data in structuredContent, human-readable narrative in content[].text',
-  '- When presenting specs, show: title, summary, key acceptance criteria, estimated effort — not the full JSON',
-  '',
-  'IDEAS BACKLOG — automatic capture:',
-  '- When a user expresses a non-urgent idea or future possibility (phrases like "sería bueno", "a futuro", "se me ocurre", "what if", "maybe we could"), call capture_idea automatically without asking. Confirm in one line.',
-].join('\n');

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,21 +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');
-function loadVersion(): string {
-  const raw: unknown = JSON.parse(readFileSync(pkgPath, 'utf8'));
-  const version =
-    typeof raw === 'object' && raw !== null && 'version' in raw ? raw.version : undefined;
-  if (
-    typeof version !== 'string' ||
-    !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/u.test(version)
-  ) {
-    throw new Error('[Planu] package.json contains an invalid release version');
-  }
-  return version;
-}
-
-export const PLANU_VERSION = loadVersion();

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