@planu/cli 4.14.1 → 5.1.1

package/dist/config/license-plans.json

@@ -1,251 +0,0 @@
-{
-  "tiers": {
-    "free": {
-      "maxProjects": 2,
-      "maxActiveSpecs": 5
-    },
-    "pro": {
-      "maxProjects": 10,
-      "maxActiveSpecs": 999999
-    },
-    "team": {
-      "maxProjects": 999999,
-      "maxActiveSpecs": 999999
-    },
-    "enterprise": {
-      "maxProjects": 999999,
-      "maxActiveSpecs": 999999
-    }
-  },
-  "freeTools": [
-    "activate_group",
-    "agent_run_history",
-    "analyze_performance_impact",
-    "analyze_spec_dependencies",
-    "approval_status",
-    "approve_spec",
-    "architecture_lint",
-    "assess_merge_risk",
-    "assign_role",
-    "audit_claude_config",
-    "audit_log_export",
-    "audit_schema_type_parity",
-    "audit_specs_drift",
-    "audit_trail",
-    "bump_spec_version",
-    "cancel_job",
-    "challenge_spec",
-    "check_compliance",
-    "check_config_health",
-    "check_parallel_safety",
-    "check_readiness",
-    "check_spec_accuracy",
-    "check_update_status",
-    "check_versions",
-    "clarify_requirements",
-    "code_graph_status",
-    "compliance_coverage_report",
-    "compliance_gap_analysis",
-    "compliance_gate_status",
-    "compliance_score_report",
-    "config_health",
-    "configure_approval_policy",
-    "configure_code_graph",
-    "configure_compliance",
-    "configure_deploy_target",
-    "configure_memory",
-    "configure_oauth",
-    "configure_observability",
-    "configure_roles",
-    "configure_squad",
-    "configure_tdd_policy",
-    "configure_telemetry",
-    "configure_webhook",
-    "configure_workers",
-    "consult_docs",
-    "context_budget",
-    "convert_to_bdd",
-    "coverage_gap_analyzer",
-    "create_rule",
-    "create_skill",
-    "create_spec",
-    "data_governance",
-    "data_retention_policy",
-    "decompose_spec",
-    "define_spec_lint_rule",
-    "define_ui_contract",
-    "delete_spec_lint_rule",
-    "deploy_spec",
-    "deploy_status",
-    "detect_agent",
-    "detect_drift",
-    "discover_docs_url",
-    "discover_mcps",
-    "discover_registry",
-    "dogfood_watch",
-    "ears_lint",
-    "ecosystem_status",
-    "enable_auto_update",
-    "estimate",
-    "estimate_ai_cost",
-    "eval_rule",
-    "eval_skill",
-    "export_audit_trail",
-    "export_spec",
-    "expose_spec_as_prompt",
-    "facilitate",
-    "feedback_status",
-    "gc_data_projects",
-    "generate_api_client",
-    "generate_attestation",
-    "generate_automation_guide",
-    "generate_batch_script",
-    "generate_checklist",
-    "generate_compliance_report",
-    "generate_compliance_tests",
-    "generate_diagram",
-    "generate_docs",
-    "generate_docs_site",
-    "generate_edge_tests",
-    "generate_execution_plan",
-    "generate_ide_config",
-    "generate_orchestration_script",
-    "generate_proposal",
-    "generate_rules",
-    "generate_skill",
-    "generate_spec_dashboard",
-    "generate_spec_from_issue",
-    "generate_sub_agent",
-    "generate_tests",
-    "generate_validation_schema",
-    "graph_specs",
-    "get_job",
-    "guided_tour",
-    "heal_spec_docs",
-    "init_constitution",
-    "init_project",
-    "integrate_pm",
-    "issue_reviewer_token",
-    "learn_pattern",
-    "legal_compliance_report",
-    "list_groups",
-    "list_registered_projects",
-    "list_spec_lint_rules",
-    "list_spec_prompts",
-    "list_specs",
-    "living_reconcile_spec",
-    "manage_context",
-    "manage_git",
-    "manage_plugins",
-    "memory_status",
-    "multi_agent_review",
-    "onboarding_checklist",
-    "onboarding_progress",
-    "orchestrate",
-    "oauth_status",
-    "outbound_webhook_status",
-    "package_handoff",
-    "paradigm_report",
-    "planu_status",
-    "publish_registry",
-    "quick_start",
-    "recommend_model",
-    "reconcile_hooks",
-    "reconcile_rules",
-    "reconcile_skills",
-    "reconcile_spec",
-    "reconcile_universal_rules",
-    "red_team",
-    "register_project_path",
-    "registry_install",
-    "registry_login",
-    "registry_logout",
-    "registry_publish",
-    "registry_search",
-    "registry_whoami",
-    "remove_webhook",
-    "render_spec_for_provider",
-    "repair_frontmatter_drift",
-    "request_changes",
-    "resolve_feedback",
-    "restart_job",
-    "reverse_engineer",
-    "rewrite_criteria_ears",
-    "run_mutation_hints",
-    "run_spec_lint",
-    "scaffold_plugin",
-    "scan_orphan_spec_refs",
-    "scan_project",
-    "search_all_projects",
-    "security_report",
-    "set_locale",
-    "set_work_mode",
-    "skill_install",
-    "skill_search",
-    "solid_check",
-    "spec_coverage",
-    "spec_obesity_healer",
-    "squad_status",
-    "ssr_back_migration",
-    "start_oauth_flow",
-    "start_onboarding",
-    "storage_export",
-    "storage_import",
-    "storage_paths",
-    "suggest_mcp_server",
-    "suggest_mcps",
-    "suggest_stack",
-    "suggest_token_optimizer",
-    "suggest_tooling",
-    "summarize_spec",
-    "submit_feedback",
-    "sync_ai_configs",
-    "sync_feedback",
-    "sync_spec_state",
-    "tdd_scaffold",
-    "tdd_status",
-    "telemetry_health",
-    "token_optimizer_status",
-    "transform_code",
-    "triage_feedback",
-    "triage_request",
-    "type_safety_gate",
-    "unregister_project_path",
-    "update_registry",
-    "update_status",
-    "update_status_batch",
-    "validate",
-    "validate_api_contract",
-    "validate_browser",
-    "validate_criteria_quality",
-    "validate_docs_registry",
-    "validate_workflow",
-    "verify_integrations",
-    "verify_spec_compliance",
-    "watch_job",
-    "worker_status"
-  ],
-  "proTools": ["audit", "design_schema", "generate_adr", "security_check"],
-  "alwaysAllowed": [
-    "activate_license",
-    "configure_compliance_gate",
-    "deactivate_license",
-    "fix_schema_type_parity",
-    "license_status",
-    "pin_version",
-    "start_dashboard",
-    "start_webhook",
-    "stop_dashboard",
-    "stop_webhook",
-    "tool_usage_report",
-    "usage_report",
-    "usage_stats",
-    "webhook_status"
-  ],
-  "variantMapping": {
-    "Planu Pro": "pro",
-    "Planu Team": "team"
-  },
-  "upgradeUrl": "https://planu.dev/pricing",
-  "freeUntil": "2026-05-13"
-}

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