calendit 1.0.3 → 2026.4.26

package/dist/core/eventkitHelper.d.ts

@@ -0,0 +1,50 @@
+/** Same directory layout as native/eventkit-bridge (Swift). */
+export declare function defaultCalenditDataDir(): string;
+/** Unix socket path when `CALENDIT_EVENTKIT_BRIDGE=1`. */
+export declare function defaultEventkitBridgeSocketPath(): string;
+export declare function bridgeTokenPath(): string;
+/**
+ * If default socket + token exist and the socket file is a real Unix socket, use the bridge
+ * (no env var required on darwin). Otherwise returns null to fall back to the helper.
+ */
+export declare function resolveAutoBridgeSocketPathIfReady(): string | null;
+/**
+ * Resolve which Unix socket the bridge is listening on for this run (if any).
+ * - Explicit: `=1` / `unix:...` (always return path; missing token is an error on connect).
+ * - `=0` / `false` / `no` / `off`: return null (always use helper process).
+ * - Unset on darwin: auto if token + live socket file exist, else null.
+ * - `=auto`: same as auto branch.
+ */
+export declare function resolveBridgeSocketPathForRun(): string | null;
+/** @deprecated use resolveBridgeSocketPathForRun */
+export declare function resolveBridgeSocketPath(): string | null;
+/** true if a helper binary exists, or a bridge socket path is in use (explicit or auto). */
+export declare function hasEventkitTransport(): boolean;
+/** 優先: CALENDIT_EVENTKIT_HELPER → リポジトリ直下の release ビルド */
+export declare function resolveEventkitHelperPath(): string | null;
+/**
+ * Run EventKit helper: **bridge** when a socket is resolved, else spawn `eventkit-helper`.
+ * Fallback to spawn only if `CALENDIT_EVENTKIT_BRIDGE_FALLBACK=1`.
+ */
+export declare function runEventkitHelper(args: string[], options?: {
+    stdin?: string;
+    timeoutMs?: number;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function eventkitDoctorJson(): Promise<{
+    ok: boolean;
+    platform?: string;
+    calendarAccess?: string;
+    helperVersion?: number;
+    transport?: string;
+}>;
+export declare function eventkitListCalendarsJson(): Promise<{
+    calendars: Array<{
+        calendarIdentifier: string;
+        title: string;
+        sourceTitle: string;
+        allowsContentModification: boolean;
+    }>;
+}>;

package/dist/core/eventkitHelper.js

@@ -0,0 +1,336 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as net from "net";
+import * as os from "os";
+import * as path from "path";
+import { t } from "./i18n.js";
+/** Same directory layout as native/eventkit-bridge (Swift). */
+export function defaultCalenditDataDir() {
+    const fromEnv = process.env.CALENDIT_CONFIG_DIR?.trim();
+    if (fromEnv) {
+        return path.resolve(fromEnv);
+    }
+    return path.join(os.homedir(), "Library", "Application Support", "calendit");
+}
+/** Unix socket path when `CALENDIT_EVENTKIT_BRIDGE=1`. */
+export function defaultEventkitBridgeSocketPath() {
+    return path.join(defaultCalenditDataDir(), "eventkit-bridge.sock");
+}
+export function bridgeTokenPath() {
+    return path.join(defaultCalenditDataDir(), "bridge.token");
+}
+const BRIDGE_DISABLE = new Set(["0", "false", "no", "off"]);
+function isBridgeExplicitlyDisabled() {
+    const raw = process.env.CALENDIT_EVENTKIT_BRIDGE?.trim();
+    if (raw === undefined) {
+        return false;
+    }
+    if (raw === "") {
+        return false;
+    }
+    return BRIDGE_DISABLE.has(raw.toLowerCase());
+}
+/**
+ * If default socket + token exist and the socket file is a real Unix socket, use the bridge
+ * (no env var required on darwin). Otherwise returns null to fall back to the helper.
+ */
+export function resolveAutoBridgeSocketPathIfReady() {
+    if (process.platform !== "darwin") {
+        return null;
+    }
+    const socketPath = defaultEventkitBridgeSocketPath();
+    const tokenPath = bridgeTokenPath();
+    if (!fs.existsSync(tokenPath)) {
+        return null;
+    }
+    if (!fs.existsSync(socketPath)) {
+        return null;
+    }
+    try {
+        if (!fs.statSync(socketPath).isSocket()) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return socketPath;
+}
+/**
+ * `CALENDIT_EVENTKIT_BRIDGE=1` / `true` or `unix:...` (explicit bridge only; no auto heuristics).
+ */
+function resolveExplicitBridgeOnly() {
+    const raw = process.env.CALENDIT_EVENTKIT_BRIDGE?.trim();
+    if (!raw || isBridgeExplicitlyDisabled()) {
+        return null;
+    }
+    const v = raw.toLowerCase();
+    if (v === "1" || v === "true" || v === "yes" || v === "on") {
+        return defaultEventkitBridgeSocketPath();
+    }
+    if (v === "auto") {
+        return null;
+    }
+    if (raw.startsWith("unix:")) {
+        let rest = raw.slice("unix:".length);
+        while (rest.startsWith("//")) {
+            rest = rest.slice(1);
+        }
+        if (!rest) {
+            return null;
+        }
+        return path.isAbsolute(rest) ? rest : path.resolve(process.cwd(), rest);
+    }
+    return null;
+}
+/**
+ * Resolve which Unix socket the bridge is listening on for this run (if any).
+ * - Explicit: `=1` / `unix:...` (always return path; missing token is an error on connect).
+ * - `=0` / `false` / `no` / `off`: return null (always use helper process).
+ * - Unset on darwin: auto if token + live socket file exist, else null.
+ * - `=auto`: same as auto branch.
+ */
+export function resolveBridgeSocketPathForRun() {
+    if (isBridgeExplicitlyDisabled()) {
+        return null;
+    }
+    const explicit = resolveExplicitBridgeOnly();
+    if (explicit) {
+        return explicit;
+    }
+    const raw = process.env.CALENDIT_EVENTKIT_BRIDGE?.trim();
+    if (raw === "auto" || !raw) {
+        return process.platform === "darwin" ? resolveAutoBridgeSocketPathIfReady() : null;
+    }
+    return null;
+}
+/** @deprecated use resolveBridgeSocketPathForRun */
+export function resolveBridgeSocketPath() {
+    return resolveBridgeSocketPathForRun();
+}
+/** true if a helper binary exists, or a bridge socket path is in use (explicit or auto). */
+export function hasEventkitTransport() {
+    if (isBridgeExplicitlyDisabled()) {
+        return resolveEventkitHelperPath() !== null;
+    }
+    return resolveEventkitHelperPath() !== null || resolveBridgeSocketPathForRun() !== null;
+}
+function readBridgeToken() {
+    const p = bridgeTokenPath();
+    if (!fs.existsSync(p)) {
+        throw new Error(`${t("eventkit.bridge.tokenMissing", { path: p })} ${t("eventkit.bridge.hintStartBridge")}`);
+    }
+    return fs.readFileSync(p, "utf8").trim();
+}
+function buildBridgePayload(args, stdin) {
+    const cmd = args[0];
+    const token = readBridgeToken();
+    if (cmd === "doctor") {
+        return { v: 1, op: "doctor", token, body: {} };
+    }
+    if (cmd === "list-calendars") {
+        return { v: 1, op: "list-calendars", token, body: {} };
+    }
+    if (cmd === "list-events") {
+        if (args.length < 4) {
+            throw new Error("list-events requires calendarId, start, end");
+        }
+        return {
+            v: 1,
+            op: "list-events",
+            token,
+            body: { calendarId: args[1], start: args[2], end: args[3] },
+        };
+    }
+    if (cmd === "create-event") {
+        let body = {};
+        if (stdin !== undefined && stdin.length > 0) {
+            body = JSON.parse(stdin);
+        }
+        return { v: 1, op: "create-event", token, body };
+    }
+    if (cmd === "update-event") {
+        let body = {};
+        if (stdin !== undefined && stdin.length > 0) {
+            body = JSON.parse(stdin);
+        }
+        return { v: 1, op: "update-event", token, body };
+    }
+    if (cmd === "delete-event") {
+        if (args.length < 3) {
+            throw new Error("delete-event requires calendarId and eventId");
+        }
+        return {
+            v: 1,
+            op: "delete-event",
+            token,
+            body: { calendarId: args[1], eventId: args[2] },
+        };
+    }
+    throw new Error(`Unknown EventKit command for bridge: ${cmd}`);
+}
+function runEventkitBridgeSocket(socketPath, args, options) {
+    const timeout = options.timeoutMs ?? 120_000;
+    const payload = buildBridgePayload(args, options.stdin);
+    const line = JSON.stringify(payload);
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection({ path: socketPath });
+        let buf = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            client.destroy();
+            reject(new Error(t("eventkit.bridge.timeout", { ms: String(timeout) })));
+        }, timeout);
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            client.destroy();
+            reject(err);
+        };
+        const ok = (stdout) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            client.end();
+            resolve({ stdout, stderr: "" });
+        };
+        client.on("error", (err) => {
+            fail(new Error(`${t("eventkit.bridge.connectFailed", { path: socketPath, message: err.message })} ${t("eventkit.bridge.hintStartBridge")}`));
+        });
+        client.on("connect", () => {
+            client.write(`${line}\n`);
+        });
+        client.on("data", (chunk) => {
+            buf += chunk.toString("utf8");
+            const nl = buf.indexOf("\n");
+            if (nl === -1) {
+                return;
+            }
+            const responseLine = buf.slice(0, nl).trim();
+            try {
+                const parsed = JSON.parse(responseLine);
+                if (parsed.bridgeError === true) {
+                    fail(new Error(String(parsed.error ?? t("eventkit.bridge.bridgeError"))));
+                    return;
+                }
+                ok(responseLine);
+            }
+            catch {
+                fail(new Error(t("eventkit.bridge.invalidJson", { line: responseLine.slice(0, 200) })));
+            }
+        });
+        client.on("close", () => {
+            if (settled)
+                return;
+            if (!buf.includes("\n")) {
+                fail(new Error(t("eventkit.bridge.closedWithoutResponse")));
+            }
+        });
+    });
+}
+function isRetryableBridgeError(err) {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    return /could not connect|ECONNREFUSED|not connect|connect ECONNREFUSED/i.test(err.message);
+}
+async function runEventkitBridgeSocketWithRetry(socketPath, args, options) {
+    const maxAttempts = 4;
+    let last;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            if (attempt > 0) {
+                await new Promise((r) => setTimeout(r, 400 * attempt));
+            }
+            return await runEventkitBridgeSocket(socketPath, args, options);
+        }
+        catch (e) {
+            last = e;
+            if (!isRetryableBridgeError(e) || attempt === maxAttempts - 1) {
+                break;
+            }
+        }
+    }
+    throw last;
+}
+async function runEventkitHelperSpawn(args, options) {
+    const exe = resolveEventkitHelperPath();
+    if (!exe) {
+        return Promise.reject(new Error(`${t("eventkit.helper.missing")} ${t("eventkit.helper.hintBuild")}`));
+    }
+    const timeout = options.timeoutMs ?? 120_000;
+    return new Promise((resolve, reject) => {
+        const child = spawn(exe, args, { stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        if (options.stdin !== undefined) {
+            child.stdin?.write(options.stdin, "utf8");
+        }
+        child.stdin?.end();
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error(t("eventkit.helper.timeout", { ms: String(timeout) })));
+        }, timeout);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                reject(new Error(stderr.trim() || t("eventkit.helper.exitCode", { code: String(code ?? "null") })));
+            }
+        });
+    });
+}
+/** 優先: CALENDIT_EVENTKIT_HELPER → リポジトリ直下の release ビルド */
+export function resolveEventkitHelperPath() {
+    const fromEnv = process.env.CALENDIT_EVENTKIT_HELPER?.trim();
+    if (fromEnv && fs.existsSync(fromEnv)) {
+        return fromEnv;
+    }
+    const rel = path.join(process.cwd(), "native", "eventkit-helper", ".build", "release", "eventkit-helper");
+    if (fs.existsSync(rel)) {
+        return rel;
+    }
+    return null;
+}
+/**
+ * Run EventKit helper: **bridge** when a socket is resolved, else spawn `eventkit-helper`.
+ * Fallback to spawn only if `CALENDIT_EVENTKIT_BRIDGE_FALLBACK=1`.
+ */
+export function runEventkitHelper(args, options = {}) {
+    const socketPath = resolveBridgeSocketPathForRun();
+    if (socketPath) {
+        return runEventkitBridgeSocketWithRetry(socketPath, args, options).catch((err) => {
+            if (process.env.CALENDIT_EVENTKIT_BRIDGE_FALLBACK === "1") {
+                return runEventkitHelperSpawn(args, options);
+            }
+            throw err;
+        });
+    }
+    return runEventkitHelperSpawn(args, options);
+}
+export async function eventkitDoctorJson() {
+    const { stdout } = await runEventkitHelper(["doctor"], { timeoutMs: 120_000 });
+    return JSON.parse(stdout.trim());
+}
+export async function eventkitListCalendarsJson() {
+    const { stdout } = await runEventkitHelper(["list-calendars"], { timeoutMs: 120_000 });
+    return JSON.parse(stdout.trim());
+}

package/dist/core/formatter.d.ts

@@ -1,4 +1,31 @@
 import { CalendarEvent } from "../types/index.js";
+import { z } from "zod";
+declare const calendarJsonSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    generated_at: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    service: z.ZodOptional<z.ZodEnum<{
+        google: "google";
+        outlook: "outlook";
+        macos: "macos";
+    }>>;
+    calendar_id: z.ZodOptional<z.ZodString>;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        summary: z.ZodString;
+        start: z.ZodString;
+        end: z.ZodString;
+        location: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        service: z.ZodOptional<z.ZodEnum<{
+            google: "google";
+            outlook: "outlook";
+            macos: "macos";
+        }>>;
+        calendar_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CalendarJsonFormat = z.infer<typeof calendarJsonSchema>;
 export interface ParseResult {
     events: Partial<CalendarEvent>[];
     warnings: string[];
@@ -22,6 +49,20 @@ export declare class Formatter {
      * インデントされた行は説明文として扱う
      */
     static fromMarkdown(md: string, strict?: boolean): ParseResult;
+    /**
+     * 予定の配列を CalendarJSON ラッパー形式の文字列に変換
+     */
+    static toJson(events: CalendarEvent[], meta?: {
+        context?: string;
+        service?: "google" | "outlook" | "macos" | "mock";
+        calendarId?: string;
+    }): string;
+    /**
+     * CalendarJSON 文字列から予定を抽出
+     * 旧来の events 配列形式も警告付きで受け入れる（後方互換）
+     */
+    static fromJson(data: string): ParseResult;
     private static groupByDate;
     private static formatTime;
 }
+export {};

package/dist/core/formatter.js

@@ -11,6 +11,24 @@ const partialEventSchema = z.object({
     location: z.string().optional(),
     description: z.string().optional(),
 });
+const jsonEventSchema = z.object({
+    id: z.string().optional(),
+    summary: z.string().min(1, "summary is required"),
+    start: z.string(),
+    end: z.string(),
+    location: z.string().optional(),
+    description: z.string().optional(),
+    service: z.enum(["google", "outlook", "macos"]).optional(),
+    calendar_id: z.string().optional(),
+});
+const calendarJsonSchema = z.object({
+    version: z.literal("1"),
+    generated_at: z.string(),
+    context: z.string().optional(),
+    service: z.enum(["google", "outlook", "macos"]).optional(),
+    calendar_id: z.string().optional(),
+    events: z.array(jsonEventSchema),
+});
 export class Formatter {
     /**
      * 予定の配列を CSV 文字列に変換
@@ -142,6 +160,67 @@ export class Formatter {
         warnings.forEach((warning) => logger.warn(warning));
         return { events, warnings };
     }
+    /**
+     * 予定の配列を CalendarJSON ラッパー形式の文字列に変換
+     */
+    static toJson(events, meta) {
+        const serviceValue = meta?.service === "google" || meta?.service === "outlook" || meta?.service === "macos" ? meta.service : undefined;
+        const payload = {
+            version: "1",
+            generated_at: new Date().toISOString(),
+            context: meta?.context,
+            service: serviceValue,
+            calendar_id: meta?.calendarId,
+            events: events.map((e) => ({
+                id: e.id,
+                summary: e.summary,
+                start: e.start,
+                end: e.end,
+                location: e.location,
+                description: e.description,
+                service: e.service,
+                calendar_id: e.calendarId,
+            })),
+        };
+        return JSON.stringify(payload, null, 2);
+    }
+    /**
+     * CalendarJSON 文字列から予定を抽出
+     * 旧来の events 配列形式も警告付きで受け入れる（後方互換）
+     */
+    static fromJson(data) {
+        const warnings = [];
+        let raw;
+        try {
+            raw = JSON.parse(data);
+        }
+        catch {
+            throw new ValidationError("JSON のパースに失敗しました。", "有効な JSON ファイルを指定してください。");
+        }
+        // 後方互換: 旧来の plain array 形式
+        if (Array.isArray(raw)) {
+            warnings.push("後方互換: イベントの配列形式を検出しました。CalendarJSON ラッパー形式（version: \"1\"）の使用を推奨します。");
+            warnings.forEach((w) => logger.warn(w));
+            return { events: raw, warnings };
+        }
+        const result = calendarJsonSchema.safeParse(raw);
+        if (!result.success) {
+            const detail = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
+            throw new ValidationError(`JSON スキーマ検証エラー: ${detail}`, "`calendit query --format json` で出力した JSON ファイルを使用してください。");
+        }
+        const events = result.data.events.map((e) => ({
+            id: e.id,
+            summary: e.summary,
+            start: e.start,
+            end: e.end,
+            location: e.location,
+            description: e.description,
+            service: e.service,
+            calendarId: e.calendar_id,
+        }));
+        warnings.forEach((w) => logger.warn(w));
+        return { events, warnings };
+    }
     static groupByDate(events) {
         const groups = {};
         for (const e of events) {

package/dist/core/i18n.d.ts

@@ -0,0 +1,7 @@
+import type { LocaleKey } from "../generated/locale-keys.js";
+export declare const SUPPORTED_UI_LOCALES: readonly ["en", "ja"];
+export type UiLocale = (typeof SUPPORTED_UI_LOCALES)[number];
+export declare function initI18n(locale: string): void;
+export declare function getActiveLocale(): UiLocale;
+export declare function t(key: LocaleKey, vars?: Record<string, string | number>): string;
+export declare function isUiLocale(value: string): value is UiLocale;

package/dist/core/i18n.js

@@ -0,0 +1,52 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { logger } from "./logger.js";
+export const SUPPORTED_UI_LOCALES = ["en", "ja"];
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function readLocaleFile(name) {
+    const file = path.join(__dirname, "..", "locales", `${name}.json`);
+    return JSON.parse(fs.readFileSync(file, "utf-8"));
+}
+const catalogs = {
+    en: readLocaleFile("en"),
+    ja: readLocaleFile("ja"),
+};
+let activeLocale = "en";
+function getByPath(obj, parts) {
+    let cur = obj;
+    for (const p of parts) {
+        if (cur === null || typeof cur !== "object" || !(p in cur))
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+function interpolate(template, vars) {
+    if (!vars)
+        return template;
+    return template.replace(/\{(\w+)\}/g, (_, key) => String(vars[key] ?? `{${key}}`));
+}
+export function initI18n(locale) {
+    activeLocale = locale === "ja" ? "ja" : "en";
+}
+export function getActiveLocale() {
+    return activeLocale;
+}
+export function t(key, vars) {
+    let raw = getByPath(catalogs[activeLocale], key.split("."));
+    if (typeof raw !== "string") {
+        raw = getByPath(catalogs.en, key.split("."));
+        if (typeof raw !== "string") {
+            logger.debug("i18n", `Missing locale key: ${key}`);
+            return key;
+        }
+        if (activeLocale !== "en") {
+            logger.debug("i18n", `Fallback to en for key: ${key}`);
+        }
+    }
+    return interpolate(raw, vars);
+}
+export function isUiLocale(value) {
+    return SUPPORTED_UI_LOCALES.includes(value);
+}

package/dist/core/localeBootstrap.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import { ConfigManager } from "./config.js";
+/** Skip locale/bootstrap IO for `--help` / `--version` only. */
+export declare function shouldSkipLocaleBootstrap(): boolean;
+/**
+ * After config is loaded, set active locale: CALENDIT_LOCALE > --locale > config.ui.locale > en.
+ */
+export declare function applyResolvedLocale(program: Command, config: ConfigManager): void;
+/**
+ * First-run language prompt when config.json is absent; then initI18n.
+ */
+export declare function ensureLocalePreference(program: Command, config: ConfigManager): Promise<void>;

package/dist/core/localeBootstrap.js

@@ -0,0 +1,74 @@
+import Enquirer from "enquirer";
+import { initI18n, isUiLocale } from "./i18n.js";
+/** Skip locale/bootstrap IO for `--help` / `--version` only. */
+export function shouldSkipLocaleBootstrap() {
+    const a = process.argv;
+    if (a.includes("--help") || a.includes("-h") || a.includes("--version") || a.includes("-V"))
+        return true;
+    return false;
+}
+function shouldSkipLocalePrompt() {
+    if (process.env.CALENDIT_SKIP_LOCALE_PROMPT === "1")
+        return true;
+    if (process.env.CALENDIT_MOCK === "true")
+        return true;
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return true;
+    return false;
+}
+function resolveLocaleFromEnvAndArgv(program) {
+    const fromEnv = process.env.CALENDIT_LOCALE?.trim();
+    if (fromEnv && isUiLocale(fromEnv))
+        return fromEnv;
+    const opts = program.optsWithGlobals();
+    if (opts.locale && isUiLocale(opts.locale))
+        return opts.locale;
+    return undefined;
+}
+/**
+ * After config is loaded, set active locale: CALENDIT_LOCALE > --locale > config.ui.locale > en.
+ */
+export function applyResolvedLocale(program, config) {
+    const fromEnvArgv = resolveLocaleFromEnvAndArgv(program);
+    if (fromEnvArgv) {
+        initI18n(fromEnvArgv);
+        return;
+    }
+    const ui = config.getUi();
+    initI18n(ui?.locale ?? "en");
+}
+/**
+ * First-run language prompt when config.json is absent; then initI18n.
+ */
+export async function ensureLocalePreference(program, config) {
+    const forced = resolveLocaleFromEnvAndArgv(program);
+    initI18n(forced ?? "en");
+    if (shouldSkipLocaleBootstrap()) {
+        return;
+    }
+    if (forced) {
+        return;
+    }
+    const loaded = await config.loadOptional();
+    if (!loaded) {
+        if (shouldSkipLocalePrompt()) {
+            config.resetMinimalWithUi("en");
+            initI18n("en");
+            return;
+        }
+        const { locale: picked } = await Enquirer.prompt({
+            type: "select",
+            name: "locale",
+            message: "Choose your language for calendit messages:",
+            choices: [
+                { name: "English", value: "en" },
+                { name: "Japanese (日本語)", value: "ja" },
+            ],
+        });
+        const locale = picked === "ja" ? "ja" : "en";
+        config.resetMinimalWithUi(locale);
+        await config.save();
+        initI18n(locale);
+        return;
+    }
+}

package/dist/core/logger.d.ts

@@ -1,6 +1,8 @@
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export declare function setLogLevel(level: LogLevel): void;
 export declare function setDebugDump(filePath: string): void;
+/** ログプレフィックスなしの標準出力（表形式のユーザー向け表示用） */
+export declare function writeStdoutLine(line: string): void;
 export declare const logger: {
     debug: (...args: unknown[]) => void;
     info: (...args: unknown[]) => void;