backlog-exporter 0.7.3 → 1.0.0

package/dist/modules/prune/domain/expected-paths.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/prune/domain/prune-target.d.ts

@@ -0,0 +1,3 @@
+import { Settings } from '../../settings/domain/settings.js';
+export type PruneTarget = 'document' | 'issue' | 'missing-folder-type' | 'not-target' | 'wiki';
+export declare function classifyPruneTarget(settings: Settings): PruneTarget;

package/dist/modules/prune/domain/prune-target.js

@@ -0,0 +1,21 @@
+import { FolderType } from '../../settings/domain/settings.js';
+// folderTypeが無いのは旧バージョンの設定ファイル。無言でスキップせず理由を伝えるためnot-targetと区別する
+export function classifyPruneTarget(settings) {
+    switch (settings.folderType) {
+        case FolderType.DOCUMENT: {
+            return 'document';
+        }
+        case FolderType.ISSUE: {
+            return 'issue';
+        }
+        case FolderType.WIKI: {
+            return 'wiki';
+        }
+        case undefined: {
+            return 'missing-folder-type';
+        }
+        default: {
+            return 'not-target';
+        }
+    }
+}

package/dist/modules/prune/repository/prune-walker.d.ts

@@ -0,0 +1,7 @@
+import { ExpectedPaths } from '../domain/expected-paths.js';
+export declare function pruneLocalMarkdownFiles(options: {
+    expected: ExpectedPaths;
+    label: string;
+    log: (message: string) => void;
+    outputDir: string;
+}): Promise<number>;

package/dist/modules/prune/repository/prune-walker.js

@@ -0,0 +1,39 @@
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { appendLog } from '../../../shared/storage/update-log.js';
+// 期待パス集合に含まれない .md ファイルと空ディレクトリを削除する。
+// 削除対象は .md のみで、設定ファイル・ログ・ユーザーが置いた他のファイルには触れない。
+// 比較はNFC正規化（macOSのNFDとAPIレスポンスのNFCの差異吸収）＋小文字化
+// （大文字小文字非区別FSでは大小文字のみのリネーム後もディスク上のエントリ名が旧表記のまま残るため。
+// 区別するFSでは旧表記が残り得るが、誤削除より安全側に倒す）で行う。
+export async function pruneLocalMarkdownFiles(options) {
+    const expectedFiles = new Set([...options.expected.expectedFiles].map((p) => p.toLowerCase()));
+    const expectedDirs = new Set([...options.expected.expectedDirs].map((p) => p.toLowerCase()));
+    let prunedCount = 0;
+    /* eslint-disable no-await-in-loop */
+    const pruneDirectory = async (dir) => {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.relative(options.outputDir, fullPath).normalize('NFC');
+            if (entry.isDirectory()) {
+                await pruneDirectory(fullPath);
+                const remaining = await fs.readdir(fullPath);
+                if (remaining.length === 0 && !expectedDirs.has(relativePath.toLowerCase())) {
+                    await fs.rmdir(fullPath);
+                    options.log(`空のディレクトリを削除しました: ${relativePath}`);
+                }
+            }
+            else if (entry.name.endsWith('.md') && !expectedFiles.has(relativePath.toLowerCase())) {
+                await fs.unlink(fullPath);
+                prunedCount++;
+                options.log(`Backlog上に存在しない${options.label}を削除しました: ${relativePath}`);
+                await appendLog(options.outputDir, `${options.label}「${relativePath}」を削除しました（Backlog上に存在しないため）`);
+            }
+        }
+    };
+    /* eslint-enable no-await-in-loop */
+    await pruneDirectory(options.outputDir);
+    options.log(`${prunedCount}件の不要な${options.label}ファイルを削除しました。`);
+    return prunedCount;
+}

package/dist/modules/prune/use-case/prune-directories.d.ts

@@ -0,0 +1,28 @@
+import { Logger } from '../../../shared/ports.js';
+import { DocumentRepository } from '../../document/domain/document-repository.js';
+import { IssueRepository } from '../../issue/domain/issue-repository.js';
+import { ProjectRepository } from '../../project/domain/project-repository.js';
+import { WikiRepository } from '../../wiki/domain/wiki-repository.js';
+export interface PruneFlags {
+    apiKey?: string;
+    domain?: string;
+    projectIdOrKey?: string;
+}
+export interface PruneDeps {
+    createRepositories: (connection: {
+        apiKey: string;
+        domain: string;
+        onRateLimitWait?: () => void;
+    }) => {
+        documentRepository: DocumentRepository;
+        issueRepository: IssueRepository;
+        projectRepository: ProjectRepository;
+        wikiRepository: WikiRepository;
+    };
+    logger: Logger;
+}
+export declare function pruneDirectories(deps: PruneDeps, options: {
+    confirmDirectory: (directory: string) => Promise<boolean>;
+    flags: PruneFlags;
+    rootDir: string;
+}): Promise<void>;

package/dist/modules/prune/use-case/prune-directories.js

@@ -0,0 +1,74 @@
+import { resolveApiKey } from '../../../shared/config/env.js';
+import { assertDirectoryExists } from '../../../shared/storage/markdown-store.js';
+import { findSettingsDirectories, loadSettings } from '../../settings/repository/settings-store.js';
+import { classifyPruneTarget } from '../domain/prune-target.js';
+import { pruneDocuments, pruneIssues, pruneWikis } from './prune-exports.js';
+export async function pruneDirectories(deps, options) {
+    const { logger } = deps;
+    await assertDirectoryExists(options.rootDir);
+    const directories = await findSettingsDirectories(options.rootDir, (dir) => {
+        logger.warn(`ディレクトリの読み取りに失敗しました: ${dir}`);
+    });
+    if (directories.length === 0) {
+        logger.warn(`設定ファイル（backlog-settings.json）が見つかりませんでした: ${options.rootDir}`);
+        return;
+    }
+    for (const directory of directories) {
+        // eslint-disable-next-line no-await-in-loop
+        await pruneDirectory(deps, directory, options.flags, options.confirmDirectory);
+    }
+}
+async function pruneDirectory(deps, targetDir, flags, confirmDirectory) {
+    const { logger } = deps;
+    const settings = await loadSettings(targetDir);
+    const target = classifyPruneTarget(settings);
+    if (target === 'missing-folder-type') {
+        logger.warn(`${targetDir}: 設定ファイルに folderType がないためスキップします（update コマンドを実行すると保存されます）`);
+        return;
+    }
+    if (target === 'not-target') {
+        return;
+    }
+    const domain = flags.domain || settings.domain;
+    const projectIdOrKey = flags.projectIdOrKey || settings.projectIdOrKey;
+    if (!domain) {
+        logger.warn(`${targetDir}: ドメインが指定されていません。スキップします。`);
+        return;
+    }
+    if (!projectIdOrKey) {
+        logger.warn(`${targetDir}: プロジェクトID/キーが指定されていません。スキップします。`);
+        return;
+    }
+    const apiKey = flags.apiKey ||
+        settings.apiKey ||
+        resolveApiKey(undefined, () => logger.log('環境変数 BACKLOG_API_KEY からAPIキーを使用します'));
+    if (!apiKey) {
+        logger.warn(`${targetDir}: APIキーが指定されていません。--apiKey フラグまたは BACKLOG_API_KEY 環境変数で設定してください。`);
+        return;
+    }
+    const confirmed = await confirmDirectory(targetDir);
+    if (!confirmed) {
+        return;
+    }
+    const { documentRepository, issueRepository, projectRepository, wikiRepository } = deps.createRepositories({
+        apiKey,
+        domain,
+        onRateLimitWait: () => logger.log('レート制限を回避するため15秒間待機します...'),
+    });
+    if (target === 'wiki') {
+        await pruneWikis({ logger, wikiRepository }, { outputDir: targetDir, projectIdOrKey });
+    }
+    else {
+        const projectId = await projectRepository.resolveProjectId(projectIdOrKey);
+        await (target === 'issue'
+            ? pruneIssues({ issueRepository, logger }, {
+                // 保存時の命名を再現するため、エクスポート時に保存された設定を使う
+                issueKeyFileName: settings.issueKeyFileName,
+                issueKeyFolder: settings.issueKeyFolder,
+                outputDir: targetDir,
+                projectId,
+            })
+            : pruneDocuments({ documentRepository, logger }, { outputDir: targetDir, projectId }));
+    }
+    logger.log(`${targetDir} のpruneが完了しました！`);
+}

package/dist/modules/prune/use-case/prune-exports.d.ts

@@ -0,0 +1,27 @@
+import { Logger } from '../../../shared/ports.js';
+import { DocumentRepository } from '../../document/domain/document-repository.js';
+import { IssueRepository } from '../../issue/domain/issue-repository.js';
+import { WikiRepository } from '../../wiki/domain/wiki-repository.js';
+export declare function pruneDocuments(deps: {
+    documentRepository: DocumentRepository;
+    logger: Logger;
+}, options: {
+    outputDir: string;
+    projectId: number;
+}): Promise<number>;
+export declare function pruneWikis(deps: {
+    logger: Logger;
+    wikiRepository: WikiRepository;
+}, options: {
+    outputDir: string;
+    projectIdOrKey: string;
+}): Promise<number>;
+export declare function pruneIssues(deps: {
+    issueRepository: IssueRepository;
+    logger: Logger;
+}, options: {
+    issueKeyFileName?: boolean;
+    issueKeyFolder?: boolean;
+    outputDir: string;
+    projectId: number;
+}): Promise<number>;

package/dist/modules/prune/use-case/prune-exports.js

@@ -0,0 +1,74 @@
+import { collectDocumentTreePaths, resolveDocumentLeafPaths } from '../../document/domain/document-path.js';
+import { buildIssueExpectedPaths } from '../../issue/domain/issue-path.js';
+import { buildWikiExpectedPaths } from '../../wiki/domain/wiki-path.js';
+import { pruneLocalMarkdownFiles } from '../repository/prune-walker.js';
+export async function pruneDocuments(deps, options) {
+    const { documentRepository, logger } = deps;
+    logger.log('Backlogのドキュメントツリーを取得しています...');
+    const documentTree = await documentRepository.fetchTree(options.projectId);
+    const expected = collectDocumentTreePaths(documentTree.activeTree.children);
+    // 保存時のファイル名は詳細のtitle基準のため、一覧APIでタイトルを解決してから期待パスを確定する
+    let titlesById = new Map();
+    if (expected.leafNodes.length > 0) {
+        logger.log(`${expected.leafNodes.length}件のドキュメントの正規ファイル名を確認しています...`);
+        try {
+            titlesById = await documentRepository.fetchAllTitles(options.projectId);
+        }
+        catch (error) {
+            // 一覧に欠けが生じると実在ドキュメントを誤削除するため、何も削除せずに中止する
+            throw new Error(`ドキュメント一覧の取得に失敗しました。誤削除を防ぐため、何も削除せずに中止します: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    resolveDocumentLeafPaths(expected, titlesById);
+    return pruneLocalMarkdownFiles({
+        expected,
+        label: 'ドキュメント',
+        log: (message) => logger.log(message),
+        outputDir: options.outputDir,
+    });
+}
+export async function pruneWikis(deps, options) {
+    const { logger, wikiRepository } = deps;
+    logger.log('BacklogのWiki一覧を取得しています...');
+    const wikis = await wikiRepository.fetchWikis(options.projectIdOrKey);
+    const expected = buildWikiExpectedPaths(wikis.map((wiki) => wiki.name));
+    return pruneLocalMarkdownFiles({
+        expected,
+        label: 'Wiki',
+        log: (message) => logger.log(message),
+        outputDir: options.outputDir,
+    });
+}
+export async function pruneIssues(deps, options) {
+    const { issueRepository, logger } = deps;
+    logger.log('Backlogの課題一覧を取得しています...');
+    // 期待集合が途中で切れると実在課題のファイルを誤削除するため、capを設けず全件を取得し、
+    // 取得に失敗した場合は何も削除せずに中止する
+    const issues = [];
+    const pageSize = 100;
+    try {
+        for (;;) {
+            // eslint-disable-next-line no-await-in-loop
+            const page = await issueRepository.fetchPage({
+                count: pageSize,
+                offset: issues.length,
+                projectId: options.projectId,
+            });
+            issues.push(...page);
+            if (page.length < pageSize) {
+                break;
+            }
+        }
+    }
+    catch (error) {
+        throw new Error(`課題一覧の取得に失敗しました。誤削除を防ぐため、何も削除せずに中止します: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    logger.log(`${issues.length}件の課題が見つかりました。`);
+    const expected = buildIssueExpectedPaths(issues, options);
+    return pruneLocalMarkdownFiles({
+        expected,
+        label: '課題',
+        log: (message) => logger.log(message),
+        outputDir: options.outputDir,
+    });
+}

package/dist/modules/settings/domain/settings.d.ts

@@ -0,0 +1,15 @@
+export declare enum FolderType {
+    DOCUMENT = "document",
+    ISSUE = "issue",
+    WIKI = "wiki"
+}
+export interface Settings {
+    apiKey?: string;
+    domain?: string;
+    folderType?: FolderType;
+    issueKeyFileName?: boolean;
+    issueKeyFolder?: boolean;
+    lastUpdated?: string;
+    outputDir?: string;
+    projectIdOrKey?: string;
+}

package/dist/modules/settings/domain/settings.js

@@ -0,0 +1,6 @@
+export var FolderType;
+(function (FolderType) {
+    FolderType["DOCUMENT"] = "document";
+    FolderType["ISSUE"] = "issue";
+    FolderType["WIKI"] = "wiki";
+})(FolderType || (FolderType = {}));

package/dist/modules/settings/repository/settings-store.d.ts

@@ -0,0 +1,6 @@
+import { Settings } from '../domain/settings.js';
+export declare function getSettingsFilePath(directory: string): string;
+export declare function loadSettings(directory: string): Promise<Settings>;
+export declare function saveSettings(directory: string, settings: Settings): Promise<void>;
+export declare function updateSettings(directory: string, newSettings: Partial<Settings>): Promise<Settings>;
+export declare function findSettingsDirectories(rootDir: string, onReadError?: (directory: string) => void): Promise<string[]>;

package/dist/modules/settings/repository/settings-store.js

@@ -0,0 +1,56 @@
+import { access, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export function getSettingsFilePath(directory) {
+    return join(directory, 'backlog-settings.json');
+}
+export async function loadSettings(directory) {
+    const settingsPath = getSettingsFilePath(directory);
+    try {
+        const data = await readFile(settingsPath, 'utf8');
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveSettings(directory, settings) {
+    const settingsPath = getSettingsFilePath(directory);
+    // ディレクトリが存在しない場合は作成
+    await mkdir(directory, { recursive: true });
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+}
+export async function updateSettings(directory, newSettings) {
+    const currentSettings = await loadSettings(directory);
+    // 新しい設定で更新（apiKeyは除外）
+    const { apiKey, ...settingsToSave } = newSettings;
+    const updatedSettings = { ...currentSettings, ...settingsToSave };
+    await saveSettings(directory, updatedSettings);
+    return { ...updatedSettings, apiKey };
+}
+// 設定ファイルを持つディレクトリを親→子の順に列挙する（update/pruneの処理順を保つ）
+export async function findSettingsDirectories(rootDir, onReadError) {
+    const found = [];
+    const walk = async (dir) => {
+        try {
+            await access(getSettingsFilePath(dir));
+            found.push(dir);
+        }
+        catch {
+            // 設定ファイルが存在しないディレクトリはスキップ
+        }
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await walk(join(dir, entry.name));
+                }
+            }
+        }
+        catch {
+            onReadError?.(dir);
+        }
+    };
+    await walk(rootDir);
+    return found;
+}

package/dist/modules/update/domain/update-plan.d.ts

@@ -0,0 +1,36 @@
+import { FolderType, Settings } from '../../settings/domain/settings.js';
+export interface UpdateFlags {
+    apiKey?: string;
+    documentId?: string;
+    documentsOnly?: boolean;
+    domain?: string;
+    force?: boolean;
+    issueIdOrKey?: string;
+    issueKeyFileName?: boolean;
+    issueKeyFolder?: boolean;
+    issuesOnly?: boolean;
+    projectIdOrKey?: string;
+    wikiId?: string;
+    wikisOnly?: boolean;
+}
+export interface UpdatePlan {
+    documentIds?: string[];
+    domain?: string;
+    folderType?: FolderType;
+    issueIdOrKeys?: string[];
+    issueKeyFileName: boolean;
+    issueKeyFolder: boolean;
+    lastUpdated?: string;
+    projectIdOrKey?: string;
+    updateDocuments: boolean;
+    updateIssues: boolean;
+    updateWikis: boolean;
+    wikiIds?: string[];
+}
+export declare function parseIds(value: string | undefined): string[] | undefined;
+export declare function determineUpdateTargets(folderType: FolderType | undefined, documentsOnly: boolean | undefined, issuesOnly: boolean | undefined, wikisOnly: boolean | undefined): {
+    updateDocuments: boolean;
+    updateIssues: boolean;
+    updateWikis: boolean;
+};
+export declare function buildUpdatePlan(settings: Settings, flags: UpdateFlags): UpdatePlan;

package/dist/modules/update/domain/update-plan.js

@@ -0,0 +1,69 @@
+import { FolderType } from '../../settings/domain/settings.js';
+export function parseIds(value) {
+    if (!value)
+        return undefined;
+    const ids = value
+        .split(',')
+        .map((id) => id.trim())
+        .filter(Boolean);
+    return ids.length > 0 ? ids : undefined;
+}
+export function determineUpdateTargets(folderType, documentsOnly, issuesOnly, wikisOnly) {
+    let updateIssues = !wikisOnly && !documentsOnly;
+    let updateWikis = !issuesOnly && !documentsOnly;
+    let updateDocuments = !issuesOnly && !wikisOnly;
+    // フォルダタイプに応じて更新対象を決定
+    switch (folderType) {
+        case FolderType.DOCUMENT: {
+            updateIssues = false;
+            updateWikis = false;
+            updateDocuments = true;
+            break;
+        }
+        case FolderType.ISSUE: {
+            updateIssues = true;
+            updateWikis = false;
+            updateDocuments = false;
+            break;
+        }
+        case FolderType.WIKI: {
+            updateIssues = false;
+            updateWikis = true;
+            updateDocuments = false;
+            break;
+        }
+    }
+    return { updateDocuments, updateIssues, updateWikis };
+}
+export function buildUpdatePlan(settings, flags) {
+    const issueIdOrKeys = parseIds(flags.issueIdOrKey);
+    const wikiIds = parseIds(flags.wikiId);
+    const documentIds = parseIds(flags.documentId);
+    // 更新対象の決定
+    const targets = determineUpdateTargets(settings.folderType, flags.documentsOnly, flags.issuesOnly, flags.wikisOnly);
+    // いずれかのID指定がある場合は「指定した項目のみ再取得」モードとし、
+    // ID指定のない種別は更新対象から外す（例: --wikiId のみ指定時は課題・ドキュメントを更新しない）
+    const hasTargetedFetch = Boolean(issueIdOrKeys || wikiIds || documentIds);
+    if (hasTargetedFetch) {
+        if (!issueIdOrKeys)
+            targets.updateIssues = false;
+        if (!wikiIds)
+            targets.updateWikis = false;
+        if (!documentIds)
+            targets.updateDocuments = false;
+    }
+    return {
+        documentIds,
+        // コマンドライン引数と設定ファイルを組み合わせて使用する値を決定
+        domain: flags.domain || settings.domain,
+        folderType: settings.folderType,
+        issueIdOrKeys,
+        // 設定ファイルからオプションを読み込み、コマンドライン引数で上書き
+        issueKeyFileName: flags.issueKeyFileName ?? settings.issueKeyFileName ?? false,
+        issueKeyFolder: flags.issueKeyFolder ?? settings.issueKeyFolder ?? false,
+        lastUpdated: settings.lastUpdated,
+        projectIdOrKey: flags.projectIdOrKey || settings.projectIdOrKey,
+        wikiIds,
+        ...targets,
+    };
+}

package/dist/modules/update/use-case/update-exports.d.ts

@@ -0,0 +1,21 @@
+import { Logger } from '../../../shared/ports.js';
+import { DocumentRepository } from '../../document/domain/document-repository.js';
+import { IssueRepository } from '../../issue/domain/issue-repository.js';
+import { ProjectRepository } from '../../project/domain/project-repository.js';
+import { WikiRepository } from '../../wiki/domain/wiki-repository.js';
+import { UpdateFlags } from '../domain/update-plan.js';
+export type { UpdateFlags } from '../domain/update-plan.js';
+export interface UpdateDeps {
+    createRepositories: (connection: {
+        apiKey: string;
+        domain: string;
+        onRateLimitWait?: () => void;
+    }) => {
+        documentRepository: DocumentRepository;
+        issueRepository: IssueRepository;
+        projectRepository: ProjectRepository;
+        wikiRepository: WikiRepository;
+    };
+    logger: Logger;
+}
+export declare function updateExports(deps: UpdateDeps, rootDir: string, flags: UpdateFlags): Promise<void>;

package/dist/modules/update/use-case/update-exports.js

@@ -0,0 +1,136 @@
+import { resolveApiKey } from '../../../shared/config/env.js';
+import { readYesNo } from '../../../shared/console/prompt.js';
+import { assertDirectoryExists, ensureDirectory } from '../../../shared/storage/markdown-store.js';
+import { exportDocuments } from '../../document/use-case/export-documents.js';
+import { exportIssues } from '../../issue/use-case/export-issues.js';
+import { FolderType } from '../../settings/domain/settings.js';
+import { findSettingsDirectories, loadSettings, updateSettings } from '../../settings/repository/settings-store.js';
+import { exportWikis } from '../../wiki/use-case/export-wikis.js';
+import { buildUpdatePlan } from '../domain/update-plan.js';
+export async function updateExports(deps, rootDir, flags) {
+    const { logger } = deps;
+    await assertDirectoryExists(rootDir);
+    const directories = await findSettingsDirectories(rootDir, (dir) => {
+        logger.warn(`ディレクトリの読み取りに失敗しました: ${dir}`);
+    });
+    if (directories.length === 0) {
+        logger.warn(`設定ファイル（backlog-settings.json）が見つかりませんでした: ${rootDir}`);
+        return;
+    }
+    for (const directory of directories) {
+        // eslint-disable-next-line no-await-in-loop
+        await updateDirectory(deps, directory, flags);
+    }
+}
+async function updateDirectory(deps, targetDir, flags) {
+    const { logger } = deps;
+    const settings = await loadSettings(targetDir);
+    const plan = buildUpdatePlan(settings, flags);
+    if (!plan.domain) {
+        logger.warn(`${targetDir}: ドメインが指定されていません。スキップします。`);
+        return;
+    }
+    if (!plan.projectIdOrKey) {
+        logger.warn(`${targetDir}: プロジェクトIDまたはキーが指定されていません。スキップします。`);
+        return;
+    }
+    const apiKey = flags.apiKey ||
+        settings.apiKey ||
+        resolveApiKey(undefined, () => logger.log('環境変数 BACKLOG_API_KEY からAPIキーを使用します'));
+    if (!apiKey) {
+        logger.warn(`${targetDir}: APIキーが指定されていません。--apiKey フラグまたは BACKLOG_API_KEY 環境変数で設定してください。`);
+        return;
+    }
+    const confirmed = await confirmUpdate(logger, targetDir, plan, flags.force || false);
+    if (!confirmed)
+        return;
+    await ensureDirectory(targetDir);
+    const { documentRepository, issueRepository, projectRepository, wikiRepository } = deps.createRepositories({
+        apiKey,
+        domain: plan.domain,
+        onRateLimitWait: () => logger.log('レート制限を回避するため15秒間待機します...'),
+    });
+    const projectId = await projectRepository.resolveProjectId(plan.projectIdOrKey);
+    logger.log(`プロジェクトID: ${projectId} を使用します`);
+    const saveFullUpdateResult = (folderType) => updateSettings(targetDir, {
+        apiKey,
+        domain: plan.domain,
+        folderType,
+        lastUpdated: new Date().toISOString(),
+        outputDir: targetDir,
+        projectIdOrKey: plan.projectIdOrKey,
+    });
+    if (plan.updateIssues) {
+        logger.log('課題の更新を開始します...');
+        await exportIssues({ issueRepository, logger }, {
+            count: 100,
+            domain: plan.domain,
+            issueIdOrKeys: plan.issueIdOrKeys,
+            issueKeyFileName: plan.issueKeyFileName,
+            issueKeyFolder: plan.issueKeyFolder,
+            // ID指定時は該当項目のみを取得するため、lastUpdatedによる絞り込みと最終更新日時の記録は行わない
+            lastUpdated: plan.issueIdOrKeys ? undefined : plan.lastUpdated,
+            outputDir: targetDir,
+            projectId,
+        });
+        if (!plan.issueIdOrKeys) {
+            await saveFullUpdateResult(FolderType.ISSUE);
+        }
+        logger.log('課題の更新が完了しました');
+    }
+    if (plan.updateWikis) {
+        logger.log('Wikiの更新を開始します...');
+        await exportWikis({ logger, wikiRepository }, {
+            domain: plan.domain,
+            lastUpdated: plan.wikiIds ? undefined : plan.lastUpdated,
+            outputDir: targetDir,
+            projectIdOrKey: plan.projectIdOrKey,
+            wikiIds: plan.wikiIds,
+        });
+        if (!plan.wikiIds) {
+            await saveFullUpdateResult(FolderType.WIKI);
+        }
+        logger.log('Wikiの更新が完了しました');
+    }
+    if (plan.updateDocuments) {
+        logger.log('ドキュメントの更新を開始します...');
+        await exportDocuments({ documentRepository, logger }, {
+            documentIds: plan.documentIds,
+            domain: plan.domain,
+            lastUpdated: plan.documentIds ? undefined : plan.lastUpdated,
+            outputDir: targetDir,
+            projectId,
+            projectIdOrKey: plan.projectIdOrKey,
+        });
+        if (!plan.documentIds) {
+            await saveFullUpdateResult(FolderType.DOCUMENT);
+        }
+        logger.log('ドキュメントの更新が完了しました');
+    }
+    logger.log(`${targetDir} の更新が完了しました！`);
+}
+async function confirmUpdate(logger, targetDir, plan, force) {
+    if (force)
+        return true;
+    logger.log(`以下の設定で更新を実行します:`);
+    logger.log(`- ディレクトリ: ${targetDir}`);
+    logger.log(`- ドメイン: ${plan.domain}`);
+    logger.log(`- プロジェクト: ${plan.projectIdOrKey}`);
+    if (plan.folderType) {
+        logger.log(`- フォルダタイプ: ${plan.folderType}`);
+    }
+    const updateTargets = [];
+    if (plan.updateIssues)
+        updateTargets.push('課題');
+    if (plan.updateWikis)
+        updateTargets.push('Wiki');
+    if (plan.updateDocuments)
+        updateTargets.push('ドキュメント');
+    logger.log(`- 更新対象: ${updateTargets.join('・')}`);
+    logger.log('更新を実行しますか？ (y/n)');
+    const response = await readYesNo();
+    if (!response) {
+        logger.log('更新をキャンセルしました');
+    }
+    return response;
+}

package/dist/modules/wiki/domain/wiki-filter.d.ts

@@ -0,0 +1,9 @@
+import { WikiSummary } from './wiki.js';
+export interface WikiSelection {
+    reason: 'all' | 'ids' | 'updatedSince';
+    wikis: WikiSummary[];
+}
+export declare function selectWikisToExport(wikis: WikiSummary[], options: {
+    lastUpdated?: string;
+    wikiIds?: string[];
+}): WikiSelection;

package/dist/modules/wiki/domain/wiki-filter.js

@@ -0,0 +1,11 @@
+export function selectWikisToExport(wikis, options) {
+    if (options.wikiIds && options.wikiIds.length > 0) {
+        const wikiIdSet = new Set(options.wikiIds.map(String));
+        return { reason: 'ids', wikis: wikis.filter((wiki) => wikiIdSet.has(String(wiki.id))) };
+    }
+    if (options.lastUpdated) {
+        const lastUpdatedDate = new Date(options.lastUpdated);
+        return { reason: 'updatedSince', wikis: wikis.filter((wiki) => new Date(wiki.updated) > lastUpdatedDate) };
+    }
+    return { reason: 'all', wikis };
+}

package/dist/modules/wiki/domain/wiki-markdown.d.ts

@@ -0,0 +1 @@
+export declare function buildWikiMarkdown(wikiName: string, backlogWikiUrl: string, content: string): string;