@poetic-ai/poetic 1.42.0

package/dist/chunk-5EERLVZB.js

@@ -0,0 +1,139 @@
+import {
+  GIT_COMMAND_TIMEOUT_MS
+} from "./chunk-LAMKBTXX.js";
+import {
+  resolveWorktreeBase
+} from "./chunk-UUH2RVKS.js";
+import {
+  getPoeticProjectRoot
+} from "./chunk-LEIIWPWQ.js";
+import {
+  isPathDebug
+} from "./chunk-EJGCZGUF.js";
+
+// src/utils/git-worktree.ts
+import { spawnSync } from "child_process";
+import { execa } from "execa";
+
+// src/constants/links.ts
+var QUICK_START_GUIDE_URL = "https://github.com/ebrindley/poetic/blob/main/docs/getting-started/QUICK_START.md";
+
+// src/constants/paths.ts
+import path from "path";
+var POETIC_CONFIG_DIR = ".poetic";
+var TELEMETRY_DB_DIR = path.join(POETIC_CONFIG_DIR, "telemetry", "db");
+var TELEMETRY_LOGS_DIR = path.join(POETIC_CONFIG_DIR, "telemetry", "logs");
+var TELEMETRY_STATE_DIR = path.join(POETIC_CONFIG_DIR, "telemetry", "state");
+function getWorktreeBaseDir() {
+  return resolveWorktreeBase();
+}
+function getPoeticRepoWorktreePoolRoot() {
+  return getWorktreeBaseDir();
+}
+function getPoeticFlywheelManifestsRoot(projectRoot = getPoeticProjectRoot()) {
+  return path.join(projectRoot, POETIC_CONFIG_DIR, "tmp", "flywheel");
+}
+function readPositiveIntEnv(name, fallback) {
+  const raw = process.env[name]?.trim();
+  if (raw === void 0 || raw === "") {
+    return fallback;
+  }
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var WORKTREE_HYGIENE_MAX_MANIFESTS_PER_PASS = readPositiveIntEnv(
+  "POETIC_WORKTREE_HYGIENE_MAX_MANIFESTS",
+  2e3
+);
+var WORKTREE_HYGIENE_MAX_RECOVERY_RECORDS_PER_PASS = readPositiveIntEnv(
+  "POETIC_WORKTREE_HYGIENE_MAX_RECOVERY_RECORDS",
+  2e3
+);
+var WORKTREE_HYGIENE_MAX_RETENTION_COLLATION = readPositiveIntEnv(
+  "POETIC_WORKTREE_HYGIENE_MAX_RETENTION_COLLATION",
+  1e4
+);
+var WORKTREE_HYGIENE_MAX_STALE_DIR_ENUM = readPositiveIntEnv(
+  "POETIC_WORKTREE_HYGIENE_MAX_STALE_DIR_ENUM",
+  5e3
+);
+var WORKTREE_HYGIENE_MAX_RETENTION_PRUNE_OPS = readPositiveIntEnv(
+  "POETIC_WORKTREE_HYGIENE_MAX_RETENTION_PRUNE_OPS",
+  2e3
+);
+var WORKTREE_HYGIENE_MAX_RETAINED_TOTAL_BYTES = (() => {
+  const raw = process.env.POETIC_WORKTREE_HYGIENE_MAX_RETAINED_TOTAL_BYTES?.trim();
+  if (raw === void 0 || raw === "") {
+    return 0;
+  }
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+})();
+if (isPathDebug()) {
+  console.log("[paths] process.cwd():", process.cwd());
+  console.log("[paths] poeticProjectRoot:", getPoeticProjectRoot());
+  console.log("[paths] worktree base:", getWorktreeBaseDir());
+}
+
+// src/utils/git-worktree.ts
+async function pruneGitWorktreeEntries(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const timeoutMs = opts.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS;
+  const warn = opts.logger?.warn ?? (() => void 0);
+  let repoRoot = cwd;
+  try {
+    const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      stdio: "pipe",
+      timeout: timeoutMs
+    });
+    repoRoot = stdout.trim() || cwd;
+  } catch {
+  }
+  try {
+    const args = ["worktree", "prune"];
+    if (opts.expireNow ?? false) {
+      args.push("--expire", "now");
+    }
+    if (opts.verbose) {
+      args.push("--verbose");
+    }
+    const result = spawnSync("git", args, {
+      cwd: repoRoot,
+      timeout: timeoutMs,
+      encoding: "utf8"
+    });
+    const stdout = result.stdout ?? "";
+    const stderr = result.stderr ?? "";
+    if (result.error) {
+      throw result.error;
+    }
+    if (typeof result.status === "number" && result.status !== 0) {
+      throw new Error(stderr || stdout || `git worktree prune exited with ${result.status}`);
+    }
+    const pruneOutput = `${stdout}
+${stderr}`;
+    const prunedEntries = pruneOutput.split("\n").filter((line) => line.trim().startsWith("Removing ")).length;
+    return { stdout, stderr, prunedEntries };
+  } catch (error) {
+    warn(
+      `Failed to prune stale worktree entries: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return { stdout: "", stderr: "", prunedEntries: 0 };
+  }
+}
+
+export {
+  QUICK_START_GUIDE_URL,
+  getWorktreeBaseDir,
+  getPoeticRepoWorktreePoolRoot,
+  getPoeticFlywheelManifestsRoot,
+  WORKTREE_HYGIENE_MAX_MANIFESTS_PER_PASS,
+  WORKTREE_HYGIENE_MAX_RECOVERY_RECORDS_PER_PASS,
+  WORKTREE_HYGIENE_MAX_RETENTION_COLLATION,
+  WORKTREE_HYGIENE_MAX_STALE_DIR_ENUM,
+  WORKTREE_HYGIENE_MAX_RETENTION_PRUNE_OPS,
+  WORKTREE_HYGIENE_MAX_RETAINED_TOTAL_BYTES,
+  pruneGitWorktreeEntries
+};
+//# sourceMappingURL=chunk-5EERLVZB.js.map

package/dist/chunk-5H72XE4H.js

@@ -0,0 +1,256 @@
+import {
+  buildProviderExecutionEnv
+} from "./chunk-APV6MK5E.js";
+import {
+  executeProviderCommand
+} from "./chunk-PFTQBXS6.js";
+import {
+  createEngineMetadata
+} from "./chunk-GHHFDU2U.js";
+import {
+  resolveProviderCliCommand
+} from "./chunk-SURZ2WFE.js";
+import {
+  PI_BACKEND_ENV_KEYS
+} from "./chunk-6TZJRKNW.js";
+
+// src/core/providers/antigravity/metadata.ts
+var metadata = createEngineMetadata(
+  {
+    id: "antigravity",
+    name: "Google Antigravity CLI",
+    description: "Google Antigravity CLI headless automation via agy",
+    cliCommand: "agy",
+    cliBinary: "agy",
+    installCommand: "curl -fsSL https://antigravity.google/cli/install.sh | bash",
+    authHint: "agy",
+    setupCommand: "poetic provider setup --providers antigravity",
+    docsPath: "docs/PROVIDER_SETUP.md",
+    docsAnchor: "antigravity-cli",
+    experimental: false
+  },
+  ["name", "description", "cliCommand", "cliBinary", "installCommand", "experimental"]
+);
+
+// src/core/providers/antigravity/auth.ts
+function hasAntigravityApiKey(env = process.env) {
+  return Boolean(env?.ANTIGRAVITY_API_KEY?.trim());
+}
+async function probeAntigravityAuthState(env) {
+  if (hasAntigravityApiKey(env)) return "yes";
+  return "unknown";
+}
+async function isAuthenticatedTriState(options = {}) {
+  const env = options?.env;
+  return probeAntigravityAuthState(env);
+}
+async function isAuthenticated(options = {}) {
+  const env = options?.env;
+  return await probeAntigravityAuthState(env) !== "no";
+}
+async function ensureAuth(options) {
+  if (await isAuthenticated(options)) return true;
+  throw new Error(
+    [
+      `${metadata.name} requires authentication.`,
+      "",
+      "To fix:",
+      `  1. Install:  ${metadata.installCommand}`,
+      `  2. Auth:     run \`${metadata.authHint}\` and complete the Google login, or export ANTIGRAVITY_API_KEY=...`,
+      `  3. Verify:   poetic doctor --provider ${metadata.id}`,
+      "",
+      `Full setup guide: ${metadata.docsPath}#${metadata.docsAnchor}`
+    ].join("\n")
+  );
+}
+async function clearAuth() {
+}
+async function nextAuthMenuAction() {
+  return "login";
+}
+var auth = {
+  isAuthenticated,
+  ensureAuth,
+  clearAuth,
+  nextAuthMenuAction
+};
+
+// src/core/providers/kiro/metadata.ts
+var metadata2 = createEngineMetadata(
+  {
+    id: "kiro",
+    name: "Kiro CLI",
+    description: "Kiro CLI headless automation via kiro-cli",
+    cliCommand: "kiro-cli",
+    cliBinary: "kiro-cli",
+    installCommand: "curl -fsSL https://cli.kiro.dev/install | bash",
+    authHint: "kiro-cli login; set KIRO_API_KEY for headless automation",
+    setupCommand: "poetic provider setup --providers kiro",
+    docsPath: "docs/PROVIDER_SETUP.md",
+    docsAnchor: "kiro-cli",
+    experimental: true
+  },
+  ["name", "description", "cliCommand", "cliBinary", "installCommand", "experimental"]
+);
+
+// src/core/providers/kiro/auth.ts
+function hasKiroApiKey(env = process.env) {
+  return Boolean(env?.KIRO_API_KEY?.trim());
+}
+async function isAuthenticated2(options = {}) {
+  const probeOptions = options.mode === "passive" ? options : { ...options, mode: "active" };
+  return await isAuthenticatedTriState2(probeOptions) === "yes";
+}
+async function isAuthenticatedTriState2(options = {}) {
+  const env = options?.env;
+  if (hasKiroApiKey(env)) return "yes";
+  const mode = options?.mode ?? "passive";
+  if (mode === "passive") {
+    return "unknown";
+  }
+  try {
+    const { command, prefixArgs } = resolveProviderCliCommand(metadata2.id);
+    const result = await executeProviderCommand({
+      command,
+      args: [...prefixArgs, "whoami", "--format", "json"],
+      workingDir: process.cwd(),
+      env: buildProviderExecutionEnv(metadata2.id, env),
+      timeout: 1e4,
+      metadata: {
+        id: metadata2.id,
+        name: metadata2.name,
+        installCommand: metadata2.installCommand,
+        authHint: metadata2.authHint,
+        docsPath: metadata2.docsPath,
+        docsAnchor: metadata2.docsAnchor
+      }
+    });
+    if (result.exitCode === 0 && result.stdout.trim().length > 0) return "yes";
+    return "no";
+  } catch {
+    return "unknown";
+  }
+}
+async function ensureAuth2(options) {
+  if (await isAuthenticated2(options)) return true;
+  throw new Error(
+    [
+      `${metadata2.name} requires authentication.`,
+      "",
+      "To fix:",
+      `  1. Install:  ${metadata2.installCommand}`,
+      `  2. Auth:     ${metadata2.authHint}`,
+      `  3. Verify:   poetic doctor --provider ${metadata2.id}`,
+      "",
+      `Full setup guide: ${metadata2.docsPath}#${metadata2.docsAnchor}`
+    ].join("\n")
+  );
+}
+async function clearAuth2() {
+  try {
+    const { command, prefixArgs } = resolveProviderCliCommand(metadata2.id);
+    await executeProviderCommand({
+      command,
+      args: [...prefixArgs, "logout"],
+      workingDir: process.cwd(),
+      env: buildProviderExecutionEnv(metadata2.id),
+      timeout: 3e4,
+      metadata: {
+        id: metadata2.id,
+        name: metadata2.name,
+        installCommand: metadata2.installCommand,
+        authHint: metadata2.authHint,
+        docsPath: metadata2.docsPath,
+        docsAnchor: metadata2.docsAnchor
+      }
+    });
+  } catch {
+  }
+}
+async function nextAuthMenuAction2(options) {
+  return await isAuthenticated2(options) ? "logout" : "login";
+}
+var auth2 = {
+  isAuthenticated: isAuthenticated2,
+  ensureAuth: ensureAuth2,
+  clearAuth: clearAuth2,
+  nextAuthMenuAction: nextAuthMenuAction2
+};
+
+// src/core/providers/pi/metadata.ts
+var metadata3 = createEngineMetadata(
+  {
+    id: "pi",
+    name: "Pi Coding Agent",
+    description: "Pi coding agent CLI with pluggable inference backends",
+    cliCommand: "pi",
+    cliBinary: "pi",
+    installCommand: "npm install -g @earendil-works/pi-coding-agent",
+    authHint: "configure a backend in ~/.pi/agent/auth.json (or export the backend key, e.g. ANTHROPIC_API_KEY)",
+    setupCommand: "poetic provider setup --providers pi",
+    docsPath: "docs/PROVIDER_SETUP.md",
+    docsAnchor: "pi-cli",
+    experimental: false
+  },
+  ["name", "description", "cliCommand", "cliBinary", "installCommand", "experimental"]
+);
+
+// src/core/providers/pi/auth.ts
+function hasBackendEnvKey(env = process.env) {
+  return PI_BACKEND_ENV_KEYS.some((key) => Boolean(env?.[key]?.trim()));
+}
+async function probePiAuthState(env) {
+  if (hasBackendEnvKey(env)) return "yes";
+  return "unknown";
+}
+async function isAuthenticatedTriState3(options = {}) {
+  const env = options?.env;
+  return probePiAuthState(env);
+}
+async function isAuthenticated3(options = {}) {
+  const env = options?.env;
+  return await probePiAuthState(env) !== "no";
+}
+async function ensureAuth3(options) {
+  if (await isAuthenticated3(options)) return true;
+  throw new Error(
+    [
+      `${metadata3.name} requires a configured inference backend.`,
+      "",
+      "To fix:",
+      `  1. Install:  ${metadata3.installCommand}`,
+      `  2. Backend:  ${metadata3.authHint}`,
+      "  3. Local:    declare an OpenAI-compatible endpoint in ~/.pi/agent/models.json",
+      `  4. Verify:   poetic doctor --provider ${metadata3.id}`,
+      "",
+      `Full setup guide: ${metadata3.docsPath}#${metadata3.docsAnchor}`
+    ].join("\n")
+  );
+}
+async function clearAuth3() {
+}
+async function nextAuthMenuAction3() {
+  return "login";
+}
+var auth3 = {
+  isAuthenticated: isAuthenticated3,
+  ensureAuth: ensureAuth3,
+  clearAuth: clearAuth3,
+  nextAuthMenuAction: nextAuthMenuAction3
+};
+
+export {
+  metadata,
+  isAuthenticatedTriState,
+  isAuthenticated,
+  auth,
+  metadata2,
+  isAuthenticated2,
+  isAuthenticatedTriState2,
+  auth2,
+  metadata3,
+  isAuthenticatedTriState3,
+  isAuthenticated3,
+  auth3
+};
+//# sourceMappingURL=chunk-5H72XE4H.js.map

package/dist/chunk-5HDP7XZG.js

@@ -0,0 +1,91 @@
+// src/core/providers/aws-credential-signals.ts
+import { readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import * as path from "path";
+function awsSharedCredentialsProfileHasStaticKeys(content, profile) {
+  const sectionName = profile.trim();
+  if (!sectionName) return false;
+  const lines = content.split(/\r?\n/);
+  let inSection = false;
+  let hasAccessKey = false;
+  let hasSecretKey = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";")) {
+      continue;
+    }
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      if (inSection) {
+        break;
+      }
+      const name = trimmed.slice(1, -1).trim();
+      inSection = name === sectionName || name === `profile ${sectionName}`;
+      continue;
+    }
+    if (!inSection) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq < 0) continue;
+    const key = trimmed.slice(0, eq).trim().toLowerCase();
+    const value = trimmed.slice(eq + 1).trim();
+    if (!value) continue;
+    if (key === "aws_access_key_id") hasAccessKey = true;
+    if (key === "aws_secret_access_key") hasSecretKey = true;
+    if (hasAccessKey && hasSecretKey) return true;
+  }
+  return hasAccessKey && hasSecretKey;
+}
+function resolveAwsHome(env) {
+  const fromEnv = env.HOME?.trim();
+  return fromEnv && fromEnv.length > 0 ? fromEnv : homedir();
+}
+function resolveAwsSharedCredentialsPath(env) {
+  const override = env.AWS_SHARED_CREDENTIALS_FILE?.trim();
+  if (override) return override;
+  return path.join(resolveAwsHome(env), ".aws", "credentials");
+}
+function resolveAwsSharedCredentialsProfileName(env) {
+  const fromProfile = env.AWS_PROFILE?.trim();
+  if (fromProfile) return fromProfile;
+  const fromDefaultProfile = env.AWS_DEFAULT_PROFILE?.trim();
+  if (fromDefaultProfile) return fromDefaultProfile;
+  return "default";
+}
+async function pathIsNonemptyFile(filePath) {
+  try {
+    const fileStat = await stat(filePath);
+    return fileStat.isFile() && fileStat.size > 0;
+  } catch {
+    return false;
+  }
+}
+async function awsProfileHasStaticKeys(profile, env) {
+  const sectionName = profile.trim();
+  if (!sectionName) return false;
+  try {
+    const raw = await readFile(resolveAwsSharedCredentialsPath(env), "utf-8");
+    return awsSharedCredentialsProfileHasStaticKeys(raw, sectionName);
+  } catch {
+    return false;
+  }
+}
+async function hasPositiveBedrockCredentialSignals(env = process.env) {
+  const accessKey = env.AWS_ACCESS_KEY_ID?.trim();
+  const secretKey = env.AWS_SECRET_ACCESS_KEY?.trim();
+  if (accessKey && secretKey) return true;
+  if (env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI?.trim()) return true;
+  if (env.AWS_CONTAINER_CREDENTIALS_FULL_URI?.trim()) return true;
+  const webIdentity = env.AWS_WEB_IDENTITY_TOKEN_FILE?.trim();
+  if (webIdentity && await pathIsNonemptyFile(webIdentity)) {
+    return true;
+  }
+  const profile = resolveAwsSharedCredentialsProfileName(env);
+  if (await awsProfileHasStaticKeys(profile, env)) {
+    return true;
+  }
+  return false;
+}
+
+export {
+  hasPositiveBedrockCredentialSignals
+};
+//# sourceMappingURL=chunk-5HDP7XZG.js.map