@ascendkit/cli 0.1.10

package/dist/tools/platform.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import * as platform from "../commands/platform.js";
+export function registerPlatformTools(server, client) {
+    server.tool("platform_login", "Log in with your AscendKit email and password. Required before using platform tools (project/environment management).", {
+        email: z.string().describe("Your AscendKit account email"),
+        password: z.string().describe("Your AscendKit account password"),
+    }, async (params) => {
+        const data = await platform.mcpLogin(client, params);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Logged in as ${data.user.email} (account: ${data.accountId})\n\n${JSON.stringify(data.user, null, 2)}`,
+                },
+            ],
+        };
+    });
+    server.tool("platform_list_projects", "List all projects in your organization", {}, async () => {
+        const data = await platform.mcpListProjects(client);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool("platform_create_project", "Create a new project in your organization", {
+        name: z.string().describe("Project name"),
+        description: z.string().optional().describe("Project description"),
+        enabledServices: z
+            .array(z.string())
+            .optional()
+            .describe('Services to enable, e.g. ["auth", "content", "surveys"]'),
+    }, async (params) => {
+        const data = await platform.mcpCreateProject(client, params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool("platform_list_environments", "List environments for a project", {
+        projectId: z.string().describe("Project ID (prj_ prefixed)"),
+    }, async (params) => {
+        const data = await platform.mcpListEnvironments(client, params.projectId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool("platform_create_environment", "Create a new environment for a project. Returns the public key needed for SDK/CLI configuration.", {
+        projectId: z.string().describe("Project ID (prj_ prefixed)"),
+        name: z
+            .string()
+            .describe('Environment name, e.g. "Development", "Production"'),
+        description: z
+            .string()
+            .optional()
+            .describe("Environment description"),
+        tier: z
+            .string()
+            .describe('Environment tier: "dev", "beta", or "prod"'),
+    }, async (params) => {
+        const data = await platform.mcpCreateEnvironment(client, params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/surveys.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AscendKitClient } from "../api/client.js";
+export declare function registerSurveyTools(server: McpServer, client: AscendKitClient): void;

package/dist/tools/surveys.js

@@ -0,0 +1,212 @@
+import { z } from "zod";
+import * as surveys from "../commands/surveys.js";
+import { formatDistributionResult, formatQuestionList, formatSingleQuestion, formatSurveyList, formatSurveyWithGuidance, } from "../utils/survey-format.js";
+export function registerSurveyTools(server, client) {
+    server.tool("survey_create", "Create a new survey. Use type 'nps' or 'csat' for ready-to-use presets with standard questions, or 'custom' to build from scratch with survey_add_question. Survey lifecycle: create → add questions → activate → distribute → collect → analyze.", {
+        name: z.string().describe("Survey name, e.g. 'Q1 NPS Survey'"),
+        type: z
+            .enum(["nps", "csat", "custom"])
+            .default("custom")
+            .describe("Survey type: 'nps' and 'csat' auto-generate definitions"),
+        definition: z
+            .record(z.unknown())
+            .optional()
+            .describe("SurveyJS-compatible JSON definition (required for type 'custom')"),
+    }, async (params) => {
+        const data = await surveys.createSurvey(client, params);
+        const formatted = formatSurveyWithGuidance(data);
+        return { content: [{ type: "text", text: formatted }] };
+    });
+    server.tool("survey_list", "List all surveys for the current project with readiness status (needs questions / draft / active / collecting responses).", {}, async () => {
+        const data = await surveys.listSurveys(client);
+        const formatted = formatSurveyList(data);
+        return { content: [{ type: "text", text: formatted }] };
+    });
+    server.tool("survey_get", "Get a survey by ID with status, question count, response count, and next-step guidance.", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+    }, async (params) => {
+        const data = await surveys.getSurvey(client, params.surveyId);
+        const formatted = formatSurveyWithGuidance(data);
+        return { content: [{ type: "text", text: formatted }] };
+    });
+    server.tool("survey_update", "Update a survey's name, definition, or status. Set status to 'active' to enable distribution, 'paused' to stop collection.", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+        name: z.string().optional().describe("New survey name"),
+        definition: z
+            .record(z.unknown())
+            .optional()
+            .describe("Updated SurveyJS definition"),
+        status: z
+            .enum(["draft", "active", "paused"])
+            .optional()
+            .describe("Survey status"),
+    }, async (params) => {
+        const { surveyId, ...rest } = params;
+        const data = await surveys.updateSurvey(client, surveyId, rest);
+        const formatted = formatSurveyWithGuidance(data);
+        return { content: [{ type: "text", text: formatted }] };
+    });
+    server.tool("survey_delete", "Delete a survey and all its invitations and responses", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+    }, async (params) => {
+        const data = await surveys.deleteSurvey(client, params.surveyId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("survey_distribute", "Distribute a survey to registered project users. Creates a unique personalized link per user for tracking (sent → opened → submitted). The survey must be active before distributing.", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+        userIds: z
+            .array(z.string())
+            .describe("List of project user IDs (usr_ prefixed) to send the survey to"),
+    }, async (params) => {
+        const data = await surveys.distributeSurvey(client, params.surveyId, params.userIds);
+        const formatted = formatDistributionResult(data);
+        return { content: [{ type: "text", text: formatted }] };
+    });
+    server.tool("survey_list_invitations", "List all invitations for a survey with their status (sent/opened/submitted)", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+    }, async (params) => {
+        const data = await surveys.listInvitations(client, params.surveyId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("survey_analytics", "Get survey analytics: funnel (sent -> opened -> submitted), conversion rates, NPS score (for NPS surveys)", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+    }, async (params) => {
+        const data = await surveys.getAnalytics(client, params.surveyId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    // --- Question-level management tools ---
+    server.tool("survey_list_questions", "List all questions in a survey in human-readable format. Shows question number, type, title, required status, choices, and any conditional logic.", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+    }, async (params) => {
+        const data = await surveys.listQuestions(client, params.surveyId);
+        const formatted = formatQuestionList(data);
+        return { content: [{ type: "text", text: formatted }] };
+    });
+    server.tool("survey_add_question", "Add a question to a survey. Supported types: text (short text), comment (long text/multi-line), radiogroup (single choice), checkbox (multiple choice), rating (scale — use rateMin:0 rateMax:10 for NPS), boolean (yes/no), dropdown, ranking. For date input, use type 'text' with inputType 'date'. Question name is auto-generated from title if not provided.", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+        type: z
+            .enum([
+            "text",
+            "comment",
+            "radiogroup",
+            "checkbox",
+            "rating",
+            "boolean",
+            "dropdown",
+            "ranking",
+        ])
+            .describe("Question type"),
+        title: z.string().describe("Question text shown to the user"),
+        name: z
+            .string()
+            .optional()
+            .describe("Unique identifier for this question (auto-generated from title if omitted)"),
+        isRequired: z
+            .boolean()
+            .default(false)
+            .describe("Whether the question must be answered"),
+        choices: z
+            .array(z.string())
+            .optional()
+            .describe("Answer options (required for radiogroup, checkbox, dropdown, ranking)"),
+        rateMin: z
+            .number()
+            .optional()
+            .describe("Minimum rating value (for rating type)"),
+        rateMax: z
+            .number()
+            .optional()
+            .describe("Maximum rating value (for rating type)"),
+        minRateDescription: z
+            .string()
+            .optional()
+            .describe("Label for minimum rating"),
+        maxRateDescription: z
+            .string()
+            .optional()
+            .describe("Label for maximum rating"),
+        inputType: z
+            .string()
+            .optional()
+            .describe("HTML input type override (e.g., 'date' for date picker)"),
+        visibleIf: z
+            .string()
+            .optional()
+            .describe("SurveyJS expression for conditional visibility (e.g., '{ease_of_setup} <= 3')"),
+        requiredIf: z
+            .string()
+            .optional()
+            .describe("SurveyJS expression for conditional required"),
+        position: z
+            .number()
+            .optional()
+            .describe("0-based position to insert at (appends to end if omitted)"),
+    }, async (params) => {
+        const { surveyId, ...rest } = params;
+        const data = await surveys.addQuestion(client, surveyId, rest);
+        const formatted = formatSingleQuestion(data, "Added");
+        return { content: [{ type: "text", text: formatted }] };
+    });
+    server.tool("survey_edit_question", "Edit an existing question in a survey by its name. Only provided fields are updated; others remain unchanged. Pass empty string for visibleIf/requiredIf to clear conditional logic.", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+        questionName: z.string().describe("Name of the question to edit"),
+        title: z.string().optional().describe("New question text"),
+        isRequired: z
+            .boolean()
+            .optional()
+            .describe("Whether the question must be answered"),
+        choices: z.array(z.string()).optional().describe("New answer options"),
+        rateMin: z.number().optional().describe("New minimum rating value"),
+        rateMax: z.number().optional().describe("New maximum rating value"),
+        minRateDescription: z
+            .string()
+            .optional()
+            .describe("New label for minimum rating"),
+        maxRateDescription: z
+            .string()
+            .optional()
+            .describe("New label for maximum rating"),
+        inputType: z.string().optional().describe("New HTML input type"),
+        visibleIf: z
+            .string()
+            .optional()
+            .describe("New visibility expression (empty string to clear)"),
+        requiredIf: z
+            .string()
+            .optional()
+            .describe("New required expression (empty string to clear)"),
+    }, async (params) => {
+        const { surveyId, questionName, ...rest } = params;
+        const data = await surveys.editQuestion(client, surveyId, questionName, rest);
+        const formatted = formatSingleQuestion(data, "Updated");
+        return { content: [{ type: "text", text: formatted }] };
+    });
+    server.tool("survey_remove_question", "Remove a question from a survey by its name. This is permanent — the question and its configuration are deleted from the survey definition.", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+        questionName: z.string().describe("Name of the question to remove"),
+    }, async (params) => {
+        await surveys.removeQuestion(client, params.surveyId, params.questionName);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Removed question '${params.questionName}' from survey.`,
+                },
+            ],
+        };
+    });
+    server.tool("survey_reorder_questions", "Reorder questions in a survey by providing all question names in the desired order. All existing question names must be included.", {
+        surveyId: z.string().describe("Survey ID (srv_ prefixed)"),
+        order: z
+            .array(z.string())
+            .describe("List of all question names in the desired display order"),
+    }, async (params) => {
+        const data = await surveys.reorderQuestions(client, params.surveyId, params.order);
+        const formatted = formatQuestionList(data);
+        return {
+            content: [
+                { type: "text", text: `Questions reordered:\n\n${formatted}` },
+            ],
+        };
+    });
+}

package/dist/tools/webhooks.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AscendKitClient } from "../api/client.js";
+export declare function registerWebhookTools(server: McpServer, client: AscendKitClient): void;

package/dist/tools/webhooks.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import * as webhooks from "../commands/webhooks.js";
+export function registerWebhookTools(server, client) {
+    server.tool("webhook_create", "Create a new webhook endpoint for the current environment. Optionally filter which events are sent to this endpoint.", {
+        url: z.string().describe("The URL to receive webhook POST requests"),
+        events: z
+            .array(z.string())
+            .optional()
+            .describe("List of event types to subscribe to (e.g. ['user.created', 'survey.completed']). Receives all events if omitted."),
+    }, async (params) => {
+        const data = await webhooks.createWebhook(client, params);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("webhook_list", "List all webhook endpoints configured for the current environment.", {}, async () => {
+        const data = await webhooks.listWebhooks(client);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("webhook_get", "Get a webhook endpoint by its config ID, including URL, subscribed events, and status.", {
+        configId: z.string().describe("Webhook config ID"),
+    }, async (params) => {
+        const data = await webhooks.getWebhook(client, params.configId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("webhook_update", "Update a webhook endpoint. Change the URL, subscribed events, or status (active/inactive). Only provided fields are changed.", {
+        configId: z.string().describe("Webhook config ID"),
+        url: z.string().optional().describe("New URL for the webhook endpoint"),
+        events: z
+            .array(z.string())
+            .optional()
+            .describe("Updated list of event types to subscribe to"),
+        status: z
+            .enum(["active", "inactive"])
+            .optional()
+            .describe("Set endpoint status: 'active' to receive events, 'inactive' to pause delivery"),
+    }, async (params) => {
+        const { configId, ...rest } = params;
+        const data = await webhooks.updateWebhook(client, configId, rest);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("webhook_delete", "Delete a webhook endpoint. This is permanent and cannot be undone.", {
+        configId: z.string().describe("Webhook config ID"),
+    }, async (params) => {
+        const data = await webhooks.deleteWebhook(client, params.configId);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+    server.tool("webhook_test", "Send a test webhook event to an endpoint. Useful for verifying your endpoint receives and processes events correctly.", {
+        configId: z.string().describe("Webhook config ID"),
+        eventType: z
+            .string()
+            .optional()
+            .describe("Event type to simulate (e.g. 'user.created'). Uses a default test event if omitted."),
+    }, async (params) => {
+        const data = await webhooks.testWebhook(client, params.configId, params.eventType);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Shared type definitions for AscendKit MCP server.
+ */
+export interface User {
+    id: string;
+    email: string;
+    name: string | null;
+    emailVerified: string | null;
+    image: string | null;
+}
+export interface Project {
+    id: string;
+    name: string;
+    publicKey: string;
+    createdAt: string;
+}
+export interface AuthSettings {
+    providers: string[];
+    features: {
+        emailVerification: boolean;
+        waitlist: boolean;
+        passwordReset: boolean;
+    };
+    sessionDuration: string;
+}
+export interface ContentTemplate {
+    id: string;
+    name: string;
+    slug?: string;
+    description?: string;
+    isSystem: boolean;
+    subject: string;
+    currentVersion: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Survey {
+    id: string;
+    name: string;
+    slug: string;
+    type: "nps" | "csat" | "custom";
+    status: "draft" | "active" | "paused";
+    stats: {
+        responseCount: number;
+        completionRate: number;
+        npsScore?: number;
+        csatAverage?: number;
+    };
+    createdAt: string;
+}
+export interface SurveyInvitation {
+    id: string;
+    surveyId: string;
+    userId: string;
+    token: string;
+    status: "sent" | "opened" | "submitted";
+    sentAt: string;
+    openedAt?: string;
+    submittedAt?: string;
+}
+export interface Journey {
+    id: string;
+    environmentId: string;
+    name: string;
+    slug: string;
+    description: string;
+    entryEvent: string;
+    entryNode: string;
+    entryConditions?: Record<string, unknown>;
+    reEntryPolicy: "skip" | "restart";
+    nodes: Record<string, {
+        action?: {
+            type?: string;
+        };
+        terminal?: boolean;
+    }>;
+    transitions: Array<{
+        from: string;
+        to: string;
+        trigger: {
+            type: "event" | "timer";
+            event?: string;
+            delay?: string;
+        };
+        priority?: number;
+    }>;
+    status: "draft" | "active" | "paused" | "archived";
+    stats: {
+        totalEnrolled: number;
+        currentlyActive: number;
+        completed: number;
+    };
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared type definitions for AscendKit MCP server.
+ */
+export {};

package/dist/utils/credentials.d.ts

@@ -0,0 +1,27 @@
+export interface AuthCredentials {
+    token: string;
+    apiUrl: string;
+}
+export interface EnvContext {
+    publicKey: string;
+    projectId: string;
+    projectName: string;
+    environmentId: string;
+    environmentName: string;
+    tier: string;
+}
+/**
+ * Walk up from cwd looking for an existing .ascendkit/ directory
+ * that contains auth.json or env.json. Falls back to cwd.
+ */
+export declare function findAscendKitRoot(): string;
+export declare function loadAuth(): AuthCredentials | null;
+/**
+ * Save auth credentials to .ascendkit/auth.json in the CURRENT directory.
+ * This is where `ascendkit init` was run.
+ */
+export declare function saveAuth(auth: AuthCredentials): void;
+export declare function deleteAuth(): void;
+export declare function loadEnvContext(): EnvContext | null;
+export declare function saveEnvContext(ctx: EnvContext): void;
+export declare function ensureGitignore(): void;

package/dist/utils/credentials.js

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync, appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+const LOCAL_DIR = ".ascendkit";
+const AUTH_FILE = "auth.json";
+const ENV_FILE = "env.json";
+/**
+ * Walk up from cwd looking for an existing .ascendkit/ directory
+ * that contains auth.json or env.json. Falls back to cwd.
+ */
+export function findAscendKitRoot() {
+    const cwd = process.cwd();
+    let search = cwd;
+    while (true) {
+        const dir = join(search, LOCAL_DIR);
+        if (existsSync(join(dir, AUTH_FILE)) || existsSync(join(dir, ENV_FILE))) {
+            return search;
+        }
+        const parent = dirname(search);
+        if (parent === search)
+            break;
+        search = parent;
+    }
+    return cwd;
+}
+function localAuthPath() {
+    return join(findAscendKitRoot(), LOCAL_DIR, AUTH_FILE);
+}
+function localEnvPath() {
+    return join(findAscendKitRoot(), LOCAL_DIR, ENV_FILE);
+}
+// --- Auth operations ---
+export function loadAuth() {
+    try {
+        const raw = readFileSync(localAuthPath(), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save auth credentials to .ascendkit/auth.json in the CURRENT directory.
+ * This is where `ascendkit init` was run.
+ */
+export function saveAuth(auth) {
+    const dir = join(process.cwd(), LOCAL_DIR);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, AUTH_FILE), JSON.stringify(auth, null, 2));
+}
+export function deleteAuth() {
+    const authPath = localAuthPath();
+    if (existsSync(authPath))
+        unlinkSync(authPath);
+}
+// --- Env context operations ---
+export function loadEnvContext() {
+    try {
+        const raw = readFileSync(localEnvPath(), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveEnvContext(ctx) {
+    const root = findAscendKitRoot();
+    const dir = join(root, LOCAL_DIR);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, ENV_FILE), JSON.stringify(ctx, null, 2));
+}
+// --- .gitignore helper ---
+export function ensureGitignore() {
+    const root = findAscendKitRoot();
+    const gitignorePath = join(root, ".gitignore");
+    const pattern = ".ascendkit/";
+    try {
+        if (existsSync(gitignorePath)) {
+            const content = readFileSync(gitignorePath, "utf-8");
+            if (content.includes(".ascendkit/") || content.includes(pattern)) {
+                return; // Already covered
+            }
+        }
+        const prefix = existsSync(gitignorePath) ? "\n" : "";
+        appendFileSync(gitignorePath, `${prefix}# AscendKit local files (contains auth/session context)\n${pattern}\n`);
+        console.log("  Added .ascendkit/ to .gitignore");
+    }
+    catch {
+        console.error("  Warning: Could not update .gitignore. Add '.ascendkit/' manually.");
+    }
+}

package/dist/utils/duration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parse a human-friendly duration string into the API's compact format.
+ *
+ * Accepted inputs:
+ *   "3 day"  | "3day"  | "3d"   → "3d"
+ *   "12 hr"  | "12hr"  | "12h"  → "12h"
+ *   "30 m"   | "30m"   | "30"   → "30m"   (bare number = minutes)
+ *   "2 week" | "2week" | "2w"   → "14d"   (weeks converted to days)
+ *
+ * Unit aliases:
+ *   minutes: m, min, minute, minutes
+ *   hours:   h, hr, hour, hours
+ *   days:    d, day, days
+ *   weeks:   w, week, weeks
+ */
+export declare function parseDelay(input: string): string;

package/dist/utils/duration.js

@@ -0,0 +1,47 @@
+/**
+ * Parse a human-friendly duration string into the API's compact format.
+ *
+ * Accepted inputs:
+ *   "3 day"  | "3day"  | "3d"   → "3d"
+ *   "12 hr"  | "12hr"  | "12h"  → "12h"
+ *   "30 m"   | "30m"   | "30"   → "30m"   (bare number = minutes)
+ *   "2 week" | "2week" | "2w"   → "14d"   (weeks converted to days)
+ *
+ * Unit aliases:
+ *   minutes: m, min, minute, minutes
+ *   hours:   h, hr, hour, hours
+ *   days:    d, day, days
+ *   weeks:   w, week, weeks
+ */
+export function parseDelay(input) {
+    const trimmed = input.trim();
+    // Already in compact format (e.g. "3d", "12h")
+    if (/^\d+[dhm]$/.test(trimmed)) {
+        return trimmed;
+    }
+    // Bare number → minutes
+    if (/^\d+$/.test(trimmed)) {
+        return `${trimmed}m`;
+    }
+    // "3 day", "12hr", "2 weeks", etc.
+    const match = trimmed.match(/^(\d+)\s*(m|min|minute|minutes|h|hr|hour|hours|d|day|days|w|week|weeks)$/i);
+    if (!match) {
+        throw new Error(`Invalid delay format: "${input}". Use a number with a unit (e.g. "3 day", "12 hr", "30 m", "2 week") or a bare number for minutes.`);
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    if (unit === "m" || unit === "min" || unit === "minute" || unit === "minutes") {
+        return `${value}m`;
+    }
+    if (unit === "h" || unit === "hr" || unit === "hour" || unit === "hours") {
+        return `${value}h`;
+    }
+    if (unit === "d" || unit === "day" || unit === "days") {
+        return `${value}d`;
+    }
+    if (unit === "w" || unit === "week" || unit === "weeks") {
+        return `${value * 7}d`;
+    }
+    // Should not reach here due to regex, but guard anyway
+    throw new Error(`Unrecognized unit: "${unit}"`);
+}