@poetic-ai/poetic 1.42.0

package/dist/chunk-NP2V3L7K.js

@@ -0,0 +1,226 @@
+// src/utils/planning-validation.ts
+import { z } from "zod";
+var TaskIdSchema = z.string().min(1, "Task ID cannot be empty").max(100, "Task ID too long (max 100 characters)").regex(
+  /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/,
+  "Task ID contains invalid characters. Only alphanumeric, dots, hyphens, and underscores allowed"
+).refine((id) => {
+  if (id.includes("..") || id.includes("/") || id.includes("\\")) {
+    return false;
+  }
+  if (id.includes("\0")) {
+    return false;
+  }
+  return true;
+}, "Task ID contains dangerous characters");
+var SprintNameSchema = z.string().min(1, "Sprint name cannot be empty").max(50, "Sprint name too long (max 50 characters)").regex(/^[a-zA-Z0-9]/, "Sprint name must start with an alphanumeric character").refine(
+  (name) => !name.includes("..") && !name.includes("/") && !name.includes("\\") && !Array.from(name).some((character) => {
+    const codePoint = character.charCodeAt(0);
+    return codePoint <= 31 || codePoint === 127;
+  }),
+  "Sprint name contains invalid characters"
+);
+var PrioritySchema = z.enum(["P0", "P1", "P2", "P3"]).describe("Priority must be P0 (critical), P1 (high), P2 (medium), or P3 (low)");
+var SeveritySchema = z.enum(["critical", "high", "medium", "low"]).describe("Severity must be: critical, high, medium, or low");
+var EffortSchema = z.enum(["low", "medium", "high"]).describe("Effort must be: low, medium, or high");
+var TaskStatusSchema = z.enum(["todo", "in_progress", "review", "done", "blocked"]).describe("Status must be: todo, in_progress, review, done, or blocked");
+var BacklogStatusSchema = z.enum(["inbox", "reviewed", "archived", "done"]).describe("Status must be: inbox, reviewed, archived, or done");
+var StoryPointsSchema = z.number().int("Story points must be an integer").min(1, "Story points must be at least 1").max(100, "Story points cannot exceed 100").refine((val) => {
+  const fibonacci = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89];
+  return fibonacci.includes(val) || val <= 100;
+}, "Story points should follow Fibonacci sequence or be reasonable values");
+var ComplexitySchema = z.number().min(0, "Complexity cannot be negative").max(1, "Complexity cannot exceed 1.0").refine((val) => !Number.isNaN(val), "Complexity must be a valid number");
+var EstimatedHoursSchema = z.number().positive("Estimated hours must be positive").max(200, "Estimated hours cannot exceed 200 (consider breaking down the task)");
+var ExpectedRuntimeMinutesSchema = z.number().positive("Expected runtime minutes must be positive").max(1440, "Expected runtime cannot exceed 1440 minutes (24h); consider breaking down the item");
+var DateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").refine((date) => {
+  const match = date.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) return false;
+  const year = Number.parseInt(match[1] ?? "", 10);
+  const month = Number.parseInt(match[2] ?? "", 10);
+  const day = Number.parseInt(match[3] ?? "", 10);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return false;
+  const parsed = new Date(Date.UTC(year, month - 1, day));
+  if (Number.isNaN(parsed.getTime())) return false;
+  if (parsed.getUTCFullYear() !== year) return false;
+  if (parsed.getUTCMonth() !== month - 1) return false;
+  if (parsed.getUTCDate() !== day) return false;
+  return true;
+}, "Invalid date");
+var DomainSchema = z.enum([
+  "general",
+  "architecture",
+  "database",
+  "performance",
+  "testing",
+  "dependencies",
+  "security",
+  "infrastructure",
+  "ui",
+  "api"
+]).describe(
+  "Invalid domain. Must be one of: general, architecture, database, performance, testing, dependencies, security, infrastructure, ui, api"
+);
+var ImpactScoreSchema = z.number().min(1, "Impact score must be at least 1").max(10, "Impact score cannot exceed 10").int("Impact score must be an integer");
+var SafeTaskDescriptionSchema = z.string().min(1, "Description cannot be empty").max(5e3, "Description too long (max 5000 characters)").transform((desc) => desc.trim()).refine((desc) => {
+  if (desc.includes("\0")) {
+    return false;
+  }
+  const dangerousPatterns = /(\$\(.*\)|`.*`|;.*&|&&|\|\|)/;
+  if (dangerousPatterns.test(desc)) {
+    return false;
+  }
+  return true;
+}, "Description contains potentially dangerous characters");
+var CheckpointPathSchema = z.string().min(1, "Checkpoint path cannot be empty").refine((path) => {
+  if (!path.endsWith(".json")) {
+    return false;
+  }
+  if (path.includes("..")) {
+    return false;
+  }
+  if (path.startsWith("/") && !path.startsWith(process.cwd())) {
+    return false;
+  }
+  if (path.includes("\0")) {
+    return false;
+  }
+  return true;
+}, "Invalid checkpoint file path");
+var CheckpointResumePathSchema = z.string().min(1, "Checkpoint path cannot be empty").refine((path) => {
+  if (!path.endsWith(".json")) {
+    return false;
+  }
+  if (path.includes("..")) {
+    return false;
+  }
+  if (path.includes("\0")) {
+    return false;
+  }
+  return true;
+}, "Invalid checkpoint file path");
+var PlanningQueryTypeSchema = z.enum(["backlog", "debt", "sprint", "task", "parking"]).describe("Query type must be: backlog, debt, sprint, task, or parking");
+var OutputFormatSchema = z.enum(["table", "json", "markdown", "yaml"]).describe("Output format must be: table, json, markdown, or yaml");
+var SchedulingOptionSchema = z.enum(["immediate", "current-sprint", "next-sprint", "backlog"]).describe("Scheduling option must be: immediate, current-sprint, next-sprint, or backlog");
+var AgentCountSchema = z.number().int("Agent count must be an integer").min(1, "At least one agent is required").max(10, "Maximum 10 agents allowed for safety");
+var BacklogAddInputSchema = z.object({
+  title: z.string().min(3, "Title must be at least 3 characters").max(200, "Title too long (max 200 characters)").transform((t) => t.trim()).refine((t) => t.length >= 3, "Title cannot be blank or whitespace-only"),
+  desc: z.string().max(5e3).optional(),
+  body: z.string().optional(),
+  bodyFile: z.string().optional(),
+  priority: PrioritySchema.optional(),
+  type: z.string().max(50).optional(),
+  workType: z.string().max(50).optional(),
+  tags: z.array(z.string().min(1).max(50)).max(20).optional(),
+  status: z.enum(["inbox", "reviewed"]).optional(),
+  complexity: z.number().min(0).max(1).optional(),
+  domain: DomainSchema.optional(),
+  expectedRuntime: ExpectedRuntimeMinutesSchema.optional(),
+  force: z.boolean().optional(),
+  sync: z.boolean().optional()
+});
+var BacklogOptionsSchema = z.object({
+  desc: z.string().optional(),
+  body: z.string().optional(),
+  // New: Full markdown body content
+  type: z.string().optional(),
+  // New: CLI --type option
+  tags: z.array(z.string()).optional(),
+  // New: CLI --tags option
+  complexity: ComplexitySchema.optional(),
+  domain: DomainSchema.optional(),
+  priority: PrioritySchema.optional(),
+  reason: z.string().max(500).optional(),
+  reconsider: DateSchema.optional(),
+  title: z.string().max(200).optional(),
+  status: BacklogStatusSchema.optional(),
+  // Updated: includes new statuses
+  approve: z.boolean().optional()
+}).strict();
+var TaskOptionsSchema = z.object({
+  sprint: SprintNameSchema.optional(),
+  priority: PrioritySchema.optional(),
+  status: TaskStatusSchema.optional(),
+  on: TaskIdSchema.optional(),
+  // for dependencies
+  force: z.boolean().optional(),
+  estimate: EstimatedHoursSchema.optional(),
+  expectedRuntime: ExpectedRuntimeMinutesSchema.optional(),
+  split: z.boolean().optional()
+}).strict();
+var SprintOptionsSchema = z.object({
+  name: SprintNameSchema.optional(),
+  start: DateSchema.optional(),
+  end: DateSchema.optional(),
+  goal: z.string().max(500).optional(),
+  hours: EstimatedHoursSchema.optional(),
+  current: z.boolean().optional(),
+  archived: z.boolean().optional(),
+  estimate: EstimatedHoursSchema.optional(),
+  priority: PrioritySchema.optional(),
+  split: z.boolean().optional()
+}).strict();
+var DebtOptionsSchema = z.object({
+  severity: SeveritySchema.optional(),
+  effort: EffortSchema.optional(),
+  impact: ImpactScoreSchema.optional(),
+  blocking: z.boolean().optional(),
+  parallelizable: z.boolean().optional(),
+  domain: DomainSchema.optional(),
+  executeBy: DateSchema.optional(),
+  targetDate: DateSchema.optional(),
+  rootCause: z.string().max(1e3).optional(),
+  hours: EstimatedHoursSchema.optional(),
+  expectedRuntime: ExpectedRuntimeMinutesSchema.optional(),
+  complexity: ComplexitySchema.optional(),
+  priority: z.boolean().optional(),
+  archived: z.boolean().optional()
+}).strict();
+var ParkingOptionsSchema = z.object({
+  reason: z.string().min(1).max(500),
+  reviewDate: DateSchema.optional(),
+  backlogId: TaskIdSchema.optional(),
+  complexity: ComplexitySchema.optional(),
+  hours: EstimatedHoursSchema.optional(),
+  current: z.boolean().optional(),
+  archived: z.boolean().optional(),
+  overdueReview: z.boolean().optional()
+}).strict();
+var PlanningOptionsSchema = z.object({
+  path: CheckpointPathSchema.optional(),
+  fix: z.boolean().optional(),
+  staged: z.boolean().optional(),
+  regenerate: z.boolean().optional(),
+  type: PlanningQueryTypeSchema.optional(),
+  status: z.string().optional(),
+  priority: PrioritySchema.optional(),
+  severity: SeveritySchema.optional(),
+  format: OutputFormatSchema.optional(),
+  json: z.boolean().optional()
+}).strict();
+var MonitorOptionsSchema = z.object({
+  json: z.boolean().optional(),
+  follow: z.boolean().optional(),
+  interval: z.number().min(1).max(300).optional(),
+  detailed: z.boolean().optional()
+}).strict();
+var PlanningCheckpointOptionsSchema = z.object({
+  agents: AgentCountSchema.optional(),
+  output: z.string().optional(),
+  resume: CheckpointResumePathSchema.optional()
+}).strict();
+
+export {
+  TaskIdSchema,
+  SprintNameSchema,
+  PrioritySchema,
+  EstimatedHoursSchema,
+  ExpectedRuntimeMinutesSchema,
+  DateSchema,
+  SafeTaskDescriptionSchema,
+  CheckpointResumePathSchema,
+  BacklogAddInputSchema,
+  BacklogOptionsSchema,
+  DebtOptionsSchema,
+  PlanningOptionsSchema,
+  PlanningCheckpointOptionsSchema
+};
+//# sourceMappingURL=chunk-NP2V3L7K.js.map

package/dist/chunk-NRLY536M.js

@@ -0,0 +1,260 @@
+import {
+  BaseProviderAuth,
+  loadProviderCredentialsConfig,
+  resolveCredential
+} from "./chunk-4VJITV4P.js";
+import {
+  createEngineMetadata
+} from "./chunk-GHHFDU2U.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/core/providers/gemini/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  clearAuth: () => clearAuth,
+  ensureAuth: () => ensureAuth,
+  getApiKeyPath: () => getApiKeyPath,
+  getGeminiAuthPaths: () => getGeminiAuthPaths,
+  getGeminiCliSelectedAuthType: () => getGeminiCliSelectedAuthType,
+  getResolvedGeminiApiKey: () => getResolvedGeminiApiKey,
+  isAuthenticated: () => isAuthenticated,
+  isAuthenticatedTriState: () => isAuthenticatedTriState,
+  isGeminiCliOAuthSelected: () => isGeminiCliOAuthSelected,
+  nextAuthMenuAction: () => nextAuthMenuAction,
+  resolveGeminiConfigDir: () => resolveGeminiConfigDir
+});
+import { existsSync } from "fs";
+import { homedir } from "os";
+import * as path from "path";
+
+// src/core/providers/gemini/metadata.ts
+var metadata = createEngineMetadata(
+  {
+    id: "gemini",
+    name: "Gemini",
+    description: "Authenticate with Google Gemini AI",
+    cliCommand: "gemini",
+    cliBinary: "gemini",
+    installCommand: "npm install -g @google/gemini-cli",
+    authHint: "export GOOGLE_API_KEY=...  # or GEMINI_API_KEY",
+    setupCommand: "poetic provider setup --providers gemini",
+    docsPath: "docs/PROVIDER_SETUP.md",
+    docsAnchor: "gemini-cli",
+    experimental: true
+  },
+  ["experimental"]
+);
+
+// src/core/providers/gemini/auth.ts
+var GeminiAuth = class extends BaseProviderAuth {
+  metadata = metadata;
+  defaultConfigSubdir = "gemini";
+  configDirEnvVar = "GEMINI_CONFIG_DIR";
+  /**
+   * Environment variables for Gemini credentials
+   */
+  getCredentialEnvVars() {
+    return ["GEMINI_API_KEY", "GOOGLE_API_KEY"];
+  }
+  /**
+   * Resolves the Gemini config directory
+   */
+  resolveConfigDir(options) {
+    if (options?.geminiConfigDir !== void 0) {
+      return super.resolveConfigDir({
+        ...options,
+        configDir: options.geminiConfigDir
+      });
+    }
+    const { profile: _profile, ...restOptions } = options ?? {};
+    return super.resolveConfigDir(restOptions);
+  }
+  /**
+   * Convert GeminiAuthOptions to base options with CLI credentials
+   */
+  toBaseOptions(options) {
+    if (!options) return {};
+    return {
+      ...options,
+      cliCredentials: options.apiKey ? {
+        apiKey: options.apiKey
+      } : options.cliCredentials
+    };
+  }
+  getAuthFilePath(configDir) {
+    return path.join(configDir, ".api_key");
+  }
+  getAuthPaths(configDir) {
+    return [
+      this.getAuthFilePath(configDir),
+      path.join(configDir, ".gemini.json"),
+      path.join(configDir, ".gemini.json.backup")
+    ];
+  }
+  async createPlaceholder(configDir) {
+    const authPath = this.getAuthFilePath(configDir);
+    const path2 = await import("path");
+    const { mkdir, writeFile } = await import("fs/promises");
+    const dir = path2.dirname(authPath);
+    await mkdir(dir, { recursive: true });
+    await writeFile(authPath, "mock-api-key", { encoding: "utf8" });
+  }
+  /**
+   * Best-effort check for whether Gemini is authenticated.
+   *
+   * Uses multi-source credential resolution with priority:
+   * 1. CLI args (--api-key)
+   * 2. Config file (.api_key or OAuth)
+   * 3. Environment variables (GEMINI_API_KEY, GOOGLE_API_KEY)
+   *
+   * This is used only for UX (e.g. "login" vs "logout" prompts). It does NOT
+   * gate normal execution – the runners always attempt to invoke the Gemini
+   * CLI and let it report authentication errors directly.
+   */
+  async isAuthenticated(options) {
+    const baseOptions = this.toBaseOptions(options);
+    const baseResult = await super.isAuthenticated(baseOptions);
+    if (baseResult) {
+      return true;
+    }
+    const explicitConfigDir = options?.configDir !== void 0 || options?.geminiConfigDir !== void 0;
+    const oauthPath = path.join(homedir(), ".gemini", "oauth_creds.json");
+    if (!explicitConfigDir && existsSync(oauthPath)) {
+      return true;
+    }
+    const config = loadProviderCredentialsConfig();
+    const configFileApiKey = config?.gemini?.apiKey ?? null;
+    const resolvedApiKey = resolveCredential({
+      cliOverride: options?.apiKey,
+      configFileValue: configFileApiKey,
+      envValue: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || void 0
+    });
+    if (resolvedApiKey) {
+      return true;
+    }
+    const configDir = this.resolveConfigDir(options);
+    const apiKeyPath = this.getAuthFilePath(configDir);
+    try {
+      const { stat } = await import("fs/promises");
+      await stat(apiKeyPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Run Gemini-specific authentication.
+   *
+   * For local development the recommended path is to use the native CLI's
+   * OAuth-based login flow:
+   *
+   *   gemini auth login
+   *
+   * Environment variable API keys remain supported for CI or non-interactive
+   * environments but are not required for normal use.
+   */
+  async runAuthCommand(_configDir) {
+    console.error("\n");
+    console.error(`  Info: ${this.metadata.name} Authentication Required`);
+    console.error("");
+    console.error("\nPoetic uses the native Gemini CLI for authentication.");
+    console.error("The recommended setup is OAuth via the CLI:\n");
+    console.error("  gemini auth login\n");
+    console.error("\nFor non-interactive environments (CI, servers), you may instead set:");
+    console.error("  export GEMINI_API_KEY=<your-api-key>\n");
+    console.error("\n");
+    throw new Error("Gemini authentication is not configured.");
+  }
+};
+var geminiAuth = new GeminiAuth();
+function resolveGeminiConfigDir(options) {
+  return geminiAuth.resolveConfigDir(options);
+}
+function getApiKeyPath(configDir) {
+  return path.join(configDir, ".api_key");
+}
+function getGeminiAuthPaths(configDir) {
+  return [
+    getApiKeyPath(configDir),
+    path.join(configDir, ".gemini.json"),
+    path.join(configDir, ".gemini.json.backup")
+  ];
+}
+async function isAuthenticated(options) {
+  return geminiAuth.isAuthenticated(options);
+}
+async function isAuthenticatedTriState(_options) {
+  return "unknown";
+}
+async function ensureAuth(options) {
+  return geminiAuth.ensureAuth(options);
+}
+async function clearAuth(options) {
+  return geminiAuth.clearAuth(options);
+}
+async function nextAuthMenuAction(options) {
+  return geminiAuth.nextAuthMenuAction(options);
+}
+function getResolvedGeminiApiKey(options) {
+  const cliOverride = options?.apiKey ?? options?.env?.GEMINI_API_KEY ?? options?.env?.GOOGLE_API_KEY ?? null;
+  const config = loadProviderCredentialsConfig();
+  const configFileValue = config?.gemini?.apiKey ?? null;
+  return resolveCredential({
+    cliOverride,
+    configFileValue,
+    envValue: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || void 0
+  });
+}
+function resolveGeminiNativeSettingsDir(options, env = process.env) {
+  if (options?.geminiConfigDir !== void 0) {
+    return options.geminiConfigDir;
+  }
+  const cliHome = env.GEMINI_CLI_HOME;
+  if (cliHome && cliHome.trim().length > 0) {
+    return cliHome.trim();
+  }
+  return path.join(env.HOME || homedir(), ".gemini");
+}
+async function getGeminiCliSelectedAuthType(options, env) {
+  const configDir = resolveGeminiNativeSettingsDir(options, env);
+  const settingsPath = path.join(configDir, "settings.json");
+  try {
+    const { readFile } = await import("fs/promises");
+    const raw = await readFile(settingsPath, "utf8");
+    const parsed = JSON.parse(String(raw));
+    const selectedType = parsed.security?.auth?.selectedType;
+    if (typeof selectedType === "string" && selectedType.trim().length > 0) {
+      return selectedType.trim();
+    }
+    const legacyMethod = parsed.auth?.method;
+    if (typeof legacyMethod === "string" && legacyMethod.trim().length > 0) {
+      return legacyMethod.trim();
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function isGeminiCliOAuthSelected(options, env) {
+  const selectedType = await getGeminiCliSelectedAuthType(options, env);
+  return selectedType?.toLowerCase().startsWith("oauth") === true;
+}
+
+export {
+  metadata,
+  resolveGeminiConfigDir,
+  getApiKeyPath,
+  getGeminiAuthPaths,
+  isAuthenticated,
+  isAuthenticatedTriState,
+  ensureAuth,
+  clearAuth,
+  nextAuthMenuAction,
+  getResolvedGeminiApiKey,
+  getGeminiCliSelectedAuthType,
+  isGeminiCliOAuthSelected,
+  auth_exports
+};
+//# sourceMappingURL=chunk-NRLY536M.js.map