@onozaty/growi-uploader 1.0.0 → 1.2.0

package/README.md

@@ -137,9 +137,11 @@ Create a `growi-uploader.json` file in your project root:
 
 ## Attachment Files
 
-### Naming Convention
+Attachments are automatically detected using two methods:
 
-Attachment files must follow this naming pattern:
+### Method 1: Naming Convention
+
+Files following this naming pattern are detected as attachments:
 
 ```
 <page-name>_attachment_<filename>
@@ -152,34 +154,66 @@ guide_attachment_image.png     → Attached to /guide
 guide_attachment_document.pdf  → Attached to /guide
 ```
 
-### Automatic Link Replacement
+### Method 2: Link-Based Detection
+
+Files referenced in markdown links are automatically detected as attachments:
 
-Markdown links to attachments are automatically converted to GROWI format.
+**Local Directory:**
+```
+guide.md
+assets/
+  banner.png
+images/
+  logo.png
+  screenshot.png
+```
 
-**Local Markdown (before upload):**
+**guide.md Content:**
 ```markdown
-# User Guide
+![Logo](./images/logo.png)
+![Screenshot](images/screenshot.png)
+![Banner](/assets/banner.png)
+```
 
-![Diagram](./guide_attachment_diagram.png)
+All referenced files (`logo.png`, `screenshot.png`, and `banner.png`) will be uploaded as attachments to the `/guide` page, even though they don't follow the `_attachment_` naming convention.
 
-Download the [documentation](guide_attachment_document.pdf).
-```
+**Path resolution:**
+- Relative paths (`./`, `../`, or no prefix): Resolved from the Markdown file's directory
+- Absolute paths (starting with `/`): Resolved from the source directory root
+  - Example: `/assets/banner.png` → `<source-dir>/assets/banner.png`
+
+**Excluded from detection:**
+- `.md` files (treated as page links)
+- External URLs (`http://`, `https://`)
+- Non-existent files
+
+### Automatic Link Replacement
+
+Markdown links to attachments are automatically converted to GROWI format (`/attachment/{id}`).
+
+**Example (Naming Convention):**
 
-**GROWI Page (after upload):**
 ```markdown
-# User Guide
+# Before upload
+![Diagram](./guide_attachment_diagram.png)
+Download the [documentation](guide_attachment_document.pdf).
 
+# After upload (on GROWI)
 ![Diagram](/attachment/68f3a41c794f665ad2c0d322)
-
 Download the [documentation](/attachment/68f3a3fa794f665ad2c0d2b3).
 ```
 
-### Supported Link Formats
+**Example (Link-Based):**
 
-Both formats are automatically detected and converted:
+```markdown
+# Before upload
+![Logo](./images/logo.png)
+
+# After upload (on GROWI)
+![Logo](/attachment/68f3a41c794f665ad2c0d322)
+```
 
-1. **Filename only**: `![alt](guide_attachment_image.png)`
-2. **Relative path**: `![alt](./guide_attachment_image.png)`
+Both detection methods support multiple link formats (with or without `./`).
 
 ## Advanced Usage
 
@@ -231,6 +265,7 @@ Completed:
 - Attachments uploaded: 2
 - Attachments skipped: 0
 - Attachment errors: 0
+- Link replacement errors: 0
 ```
 
 ## Requirements

package/dist/index.mjs

@@ -1,23 +1,39 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { basename, dirname, join, resolve } from "node:path";
-import { readFileSync } from "node:fs";
-import { glob } from "glob";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 import * as axios$1 from "axios";
 import axios from "axios";
 import { lookup } from "mime-types";
+import { glob } from "glob";
+
+//#region package.json
+var version = "1.2.0";
 
+//#endregion
 //#region src/config.ts
+/**
+* Load configuration from JSON file
+*
+* @param configPath - Path to the configuration file
+* @returns Configuration object with defaults applied:
+*   - basePath defaults to "/" if not specified or empty
+*   - update defaults to false if not specified
+* @throws Error if config file is not found or required fields (url, token) are missing
+*/
 const loadConfig = (configPath) => {
 	const fullPath = resolve(configPath);
 	try {
 		const content = readFileSync(fullPath, "utf-8");
-		const config = JSON.parse(content);
-		if (!config.url) throw new Error("Missing required field: url");
-		if (!config.token) throw new Error("Missing required field: token");
-		if (config.basePath === void 0) config.basePath = "/";
-		if (config.update === void 0) config.update = false;
-		return config;
+		const input = JSON.parse(content);
+		if (!input.url) throw new Error("Missing required field: url");
+		if (!input.token) throw new Error("Missing required field: token");
+		return {
+			url: input.url,
+			token: input.token,
+			basePath: input.basePath || "/",
+			update: input.update ?? false
+		};
 	} catch (error) {
 		if (error.code === "ENOENT") throw new Error(`Config file not found: ${fullPath}`);
 		throw error;
@@ -25,36 +41,7 @@ const loadConfig = (configPath) => {
 };
 
 //#endregion
-//#region src/scanner.ts
-const scanMarkdownFiles = async (sourceDir, basePath = "/") => {
-	const mdFiles = await glob("**/*.md", {
-		cwd: sourceDir,
-		absolute: false
-	});
-	mdFiles.sort();
-	return await Promise.all(mdFiles.map(async (file) => {
-		const content = readFileSync(join(sourceDir, file), "utf-8");
-		const growiPath = join(basePath, file.replace(/\.md$/, "")).replace(/\\/g, "/");
-		const dir = dirname(file);
-		const pageName = basename(file, ".md");
-		const attachments = (await glob(dir === "." ? `${pageName}_attachment_*` : `${dir}/${pageName}_attachment_*`, {
-			cwd: sourceDir,
-			absolute: false
-		})).map((attachFile) => ({
-			localPath: attachFile,
-			fileName: basename(attachFile).replace(`${pageName}_attachment_`, "")
-		}));
-		return {
-			localPath: file,
-			growiPath: growiPath.startsWith("/") ? growiPath : `/${growiPath}`,
-			content,
-			attachments
-		};
-	}));
-};
-
-//#endregion
-//#region src/growi.ts
+//#region src/generated/growi.ts
 /**
 * Add attachment to the page
 * @summary /attachment
@@ -90,83 +77,255 @@ const putPage = (putPageBody, options) => {
 };
 
 //#endregion
-//#region src/uploader.ts
+//#region src/growi-client.ts
+/**
+* Configure axios with GROWI API endpoint and authentication
+*
+* @param growiUrl GROWI base URL (e.g., "https://example.com")
+* @param token API token for authentication
+*/
 const configureAxios = (growiUrl, token) => {
 	axios.defaults.baseURL = `${growiUrl}/_api/v3`;
 	axios.defaults.headers.common["Authorization"] = `Bearer ${token}`;
 };
-const createOrUpdatePage = async (file, config) => {
+/**
+* Format error into a human-readable error message
+*
+* @param error Error object from catch block
+* @returns Formatted error message string
+*/
+const formatErrorMessage = (error) => {
+	if (axios.isAxiosError(error)) return `${error.response?.status} ${error.response?.data?.message || error.message}`;
+	if (error instanceof Error) return error.message;
+	return String(error);
+};
+/**
+* Create a new page or update an existing page in GROWI
+*
+* @param file Markdown file to upload
+* @param content Markdown content
+* @param shouldUpdate If true, update existing pages; if false, skip existing pages
+* @returns Result containing page ID, revision ID, and action taken
+*/
+const createOrUpdatePage = async (file, content, shouldUpdate) => {
 	try {
 		const actualResponse = (await getPage({ path: file.growiPath })).data;
 		if (actualResponse.page) {
 			const pageId = actualResponse.page._id;
 			const revisionId = actualResponse.page.revision?._id;
-			if (!config.update) {
-				console.log(`[SKIP] ${file.localPath} → ${file.growiPath} (page already exists)`);
-				return {
-					pageId,
-					revisionId,
-					action: "skipped"
-				};
-			}
-			const newRevisionId = (await putPage({
-				body: file.content,
+			if (!shouldUpdate) return {
 				pageId,
-				revisionId
-			})).data.page?.revision;
-			console.log(`[SUCCESS] ${file.localPath} → ${file.growiPath} (updated)`);
+				revisionId,
+				action: "skipped"
+			};
 			return {
 				pageId,
-				revisionId: newRevisionId || revisionId,
+				revisionId: (await putPage({
+					body: content,
+					pageId,
+					revisionId
+				})).data.page?.revision,
 				action: "updated"
 			};
 		}
 	} catch (error) {
-		if (!axios.isAxiosError(error) || error.response?.status !== 404) {
-			if (axios.isAxiosError(error)) {
-				const status = error.response?.status;
-				const message = error.response?.data?.message || error.message;
-				console.error(`[ERROR] ${file.localPath} → ${file.growiPath} (${status} ${message})`);
-			} else console.error(`[ERROR] ${file.localPath} → ${file.growiPath} (${error})`);
-			return {
-				pageId: void 0,
-				revisionId: void 0,
-				action: "error"
-			};
-		}
+		if (!axios.isAxiosError(error) || error.response?.status !== 404) return {
+			pageId: void 0,
+			revisionId: void 0,
+			action: "error",
+			errorMessage: formatErrorMessage(error)
+		};
 	}
 	try {
 		const response = await postPage({
 			path: file.growiPath,
-			body: file.content
+			body: content
 		});
-		const pageId = response.data.page?._id;
-		const revisionId = response.data.page?.revision;
-		console.log(`[SUCCESS] ${file.localPath} → ${file.growiPath} (created)`);
 		return {
-			pageId,
-			revisionId,
+			pageId: response.data.page?._id,
+			revisionId: response.data.page?.revision,
 			action: "created"
 		};
 	} catch (error) {
-		if (axios.isAxiosError(error)) {
-			const status = error.response?.status;
-			const message = error.response?.data?.message || error.message;
-			console.error(`[ERROR] ${file.localPath} → ${file.growiPath} (${status} ${message})`);
-		} else console.error(`[ERROR] ${file.localPath} → ${file.growiPath} (${error})`);
 		return {
 			pageId: void 0,
 			revisionId: void 0,
-			action: "error"
+			action: "error",
+			errorMessage: formatErrorMessage(error)
+		};
+	}
+};
+/**
+* Update page content with new Markdown content
+*
+* @param pageId Page ID
+* @param revisionId Current revision ID
+* @param content New Markdown content
+* @returns Result containing success status, new revision ID, or error message
+*/
+const updatePageContent = async (pageId, revisionId, content) => {
+	try {
+		const newRevisionId = (await putPage({
+			body: content,
+			pageId,
+			revisionId
+		})).data.page?.revision;
+		return {
+			success: true,
+			...newRevisionId && { revisionId: newRevisionId }
 		};
+	} catch (error) {
+		return {
+			success: false,
+			errorMessage: formatErrorMessage(error)
+		};
+	}
+};
+/**
+* Upload an attachment file to a GROWI page
+*
+* @param attachment Attachment file to upload
+* @param pageId Page ID to attach the file to
+* @param sourceDir Source directory containing the attachment file
+* @returns Result containing attachment ID, revision ID, and success status
+*/
+const uploadAttachment = async (attachment, pageId, sourceDir) => {
+	try {
+		const fileBuffer = readFileSync(join(sourceDir, attachment.localPath));
+		const mimeType = lookup(attachment.fileName) || "application/octet-stream";
+		const formData = new FormData();
+		formData.append("page_id", pageId);
+		formData.append("file", new Blob([fileBuffer], { type: mimeType }), attachment.fileName);
+		const response = await postAttachment(formData);
+		const attachmentId = response.data.attachment?._id;
+		const revisionId = typeof response.data.revision === "string" ? response.data.revision : void 0;
+		return {
+			success: true,
+			...attachmentId && { attachmentId },
+			...revisionId && { revisionId }
+		};
+	} catch (error) {
+		return {
+			success: false,
+			errorMessage: formatErrorMessage(error)
+		};
+	}
+};
+
+//#endregion
+//#region src/scanner.ts
+/**
+* Extract attachment files from markdown links
+*
+* Scans markdown content for image and link references, resolves their paths,
+* and returns those that exist as files (excluding .md files and external URLs).
+*
+* @param content Markdown content
+* @param markdownFilePath Path to the markdown file (relative to sourceDir)
+* @param sourceDir Source directory (absolute path)
+* @returns Array of attachment files found via links
+*/
+const extractLinkedAttachments = (content, markdownFilePath, sourceDir) => {
+	const attachments = [];
+	const linkRegex = new RegExp([
+		"!?",
+		"\\[(?<alt>[^\\]]*)\\]",
+		"\\(",
+		"(?:",
+		"<(?<anglePath>[^>]+)>",
+		"|",
+		"(?<regularPath>(?:[^)\\\\]+|\\\\.)*)",
+		")",
+		"\\)"
+	].join(""), "g");
+	let match;
+	while ((match = linkRegex.exec(content)) !== null) {
+		const { anglePath, regularPath } = match.groups;
+		const linkPath = anglePath || regularPath;
+		if (!linkPath) continue;
+		const originalLinkPath = anglePath ? `<${anglePath}>` : regularPath;
+		if (linkPath.startsWith("http://") || linkPath.startsWith("https://")) continue;
+		if (linkPath.endsWith(".md")) continue;
+		const unescapedPath = linkPath.replace(/\\([\\`*_{}[\]()#+\-.!])/g, "$1");
+		let absolutePath;
+		if (linkPath.startsWith("/")) absolutePath = resolve(sourceDir, unescapedPath.slice(1));
+		else absolutePath = resolve(dirname(join(sourceDir, markdownFilePath)), unescapedPath);
+		if (!existsSync(absolutePath)) continue;
+		const normalizedPath = relative(sourceDir, absolutePath).replace(/\\/g, "/");
+		attachments.push({
+			localPath: normalizedPath,
+			fileName: basename(normalizedPath),
+			detectionPattern: "link",
+			originalLinkPaths: [originalLinkPath]
+		});
 	}
+	return attachments;
+};
+/**
+* Merge attachments from naming pattern and link pattern, removing duplicates
+*
+* If the same file is detected by both patterns, it will be kept as a single
+* attachment with merged originalLinkPaths.
+*
+* @param namingAttachments Attachments detected by naming pattern
+* @param linkAttachments Attachments detected by link pattern
+* @returns Merged array with duplicates removed
+*/
+const mergeAttachments = (namingAttachments, linkAttachments) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const att of namingAttachments) map.set(att.localPath, att);
+	for (const att of linkAttachments) {
+		const existing = map.get(att.localPath);
+		if (existing) {
+			if (!existing.originalLinkPaths) existing.originalLinkPaths = [];
+			if (att.originalLinkPaths) existing.originalLinkPaths.push(...att.originalLinkPaths);
+		} else map.set(att.localPath, att);
+	}
+	return Array.from(map.values());
+};
+const scanMarkdownFiles = async (sourceDir, basePath = "/") => {
+	const pageFiles = (await glob("**/*.md", {
+		cwd: sourceDir,
+		absolute: false
+	})).filter((file) => !basename(file).includes("_attachment_"));
+	pageFiles.sort();
+	return await Promise.all(pageFiles.map(async (file) => {
+		const content = readFileSync(join(sourceDir, file), "utf-8");
+		const growiPath = join(basePath, file.replace(/\.md$/, "")).replace(/\\/g, "/");
+		const dir = dirname(file);
+		const pageName = basename(file, ".md");
+		const attachments = mergeAttachments((await glob(dir === "." ? `${pageName}_attachment_*` : `${dir}/${pageName}_attachment_*`, {
+			cwd: sourceDir,
+			absolute: false
+		})).map((attachFile) => ({
+			localPath: attachFile,
+			fileName: basename(attachFile).replace(`${pageName}_attachment_`, ""),
+			detectionPattern: "naming"
+		})), extractLinkedAttachments(content, file, sourceDir));
+		return {
+			localPath: file,
+			growiPath: growiPath.startsWith("/") ? growiPath : `/${growiPath}`,
+			attachments
+		};
+	}));
+};
+
+//#endregion
+//#region src/markdown.ts
+/**
+* Escape special regex characters for safe use in RegExp
+* Escapes: . * + ? ^ $ { } ( ) | [ ] \ < >
+* Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
+*/
+const escapeRegex = (str) => {
+	return str.replace(/[.*+?^${}()|[\]\\<>]/g, "\\$&");
 };
 /**
 * Replace attachment links in Markdown content with GROWI format
 *
-* Supports:
-* - Filename only: guide_attachment_file.png
-* - Relative path: ./guide_attachment_file.png
+* Supports two detection patterns:
+* 1. Naming pattern: guide_attachment_file.png, ./guide_attachment_file.png
+* 2. Link pattern: ./images/photo.jpg, images/photo.jpg (as found in markdown)
 *
 * @param markdown Original Markdown content
 * @param attachments List of attachments with their IDs
@@ -178,10 +337,20 @@ const replaceAttachmentLinks = (markdown, attachments, pageName) => {
 	let replaced = false;
 	for (const attachment of attachments) {
 		if (!attachment.attachmentId) continue;
-		const localFileName = `${pageName}_attachment_${attachment.fileName}`;
 		const growiPath = `/attachment/${attachment.attachmentId}`;
-		const escapedFileName = localFileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-		const patterns = [escapedFileName, `\\./${escapedFileName}`];
+		const patterns = [];
+		if (attachment.detectionPattern === "naming") {
+			const escapedFileName = escapeRegex(`${pageName}_attachment_${attachment.fileName}`);
+			patterns.push(escapedFileName, `\\./${escapedFileName}`);
+		}
+		if (attachment.detectionPattern === "link" && attachment.originalLinkPaths) for (const linkPath of attachment.originalLinkPaths) {
+			const escapedPath = escapeRegex(linkPath);
+			patterns.push(escapedPath);
+			if (linkPath.startsWith("./")) {
+				const escapedWithoutDot = escapeRegex(linkPath.substring(2));
+				patterns.push(escapedWithoutDot);
+			} else if (!linkPath.startsWith("../")) patterns.push(`\\./${escapedPath}`);
+		}
 		for (const pattern of patterns) {
 			const imgRegex = new RegExp(`!\\[([^\\]]*)\\]\\(${pattern}\\)`, "g");
 			if (imgRegex.test(result)) {
@@ -201,197 +370,165 @@ const replaceAttachmentLinks = (markdown, attachments, pageName) => {
 	};
 };
 /**
-* Update page content only (for re-updating after attachment link replacement)
+* Replace .md extension in page links with GROWI format
 *
-* @param pageId Page ID
-* @param revisionId Current revision ID
-* @param content New Markdown content
-* @param growiPath GROWI page path (for logging)
-* @returns True if update succeeded
+* Converts Markdown page links to GROWI-compatible format by removing .md extension.
+* For absolute paths (starting with /), prepends basePath to the link.
+* External URLs (http://, https://) are excluded from replacement.
+*
+* Supported patterns:
+* - Relative path: [text](./page.md) → [text](./page)
+* - Filename only: [text](page.md) → [text](page)
+* - Absolute path: [text](/docs/page.md) → [text](/basePath/docs/page)
+* - With anchor: [text](./page.md#section) → [text](./page#section)
+*
+* @param markdown Original Markdown content
+* @param basePath Base path for GROWI pages (default: "/")
+* @returns Object with replaced content and whether any replacement occurred
 */
-const updatePageContent = async (pageId, revisionId, content, growiPath) => {
-	try {
-		await putPage({
-			body: content,
-			pageId,
-			revisionId
-		});
-		return true;
-	} catch (error) {
-		if (axios.isAxiosError(error)) {
-			const status = error.response?.status;
-			const message = error.response?.data?.message || error.message;
-			console.error(`[WARN] Failed to update attachment links for ${growiPath} (${status} ${message})`);
-		} else console.error(`[WARN] Failed to update attachment links for ${growiPath}`);
-		return false;
-	}
-};
-const uploadAttachment = async (attachment, pageId, growiPath, sourceDir) => {
-	try {
-		const fileBuffer = readFileSync(join(sourceDir, attachment.localPath));
-		const mimeType = lookup(attachment.fileName) || "application/octet-stream";
-		const formData = new FormData();
-		formData.append("page_id", pageId);
-		formData.append("file", new Blob([fileBuffer], { type: mimeType }), attachment.fileName);
-		const response = await postAttachment(formData);
-		const attachmentId = response.data.attachment?._id;
-		const revisionId = typeof response.data.revision === "string" ? response.data.revision : void 0;
-		console.log(`[SUCCESS] ${attachment.localPath} → ${growiPath} (attachment)`);
-		if (attachmentId && revisionId) return {
-			success: true,
-			attachmentId,
-			revisionId
-		};
-		else if (attachmentId) return {
-			success: true,
-			attachmentId
-		};
-		else if (revisionId) return {
-			success: true,
-			revisionId
-		};
-		else return { success: true };
-	} catch (error) {
-		if (axios.isAxiosError(error)) {
-			const status = error.response?.status;
-			const message = error.response?.data?.message || error.message;
-			console.error(`[ERROR] ${attachment.localPath} → ${growiPath} (${status} ${message})`);
-		} else console.error(`[ERROR] ${attachment.localPath} → ${growiPath} (${error})`);
-		return { success: false };
-	}
-};
-
-//#endregion
-//#region package.json
-var name = "@onozaty/growi-uploader";
-var version = "1.0.0";
-var description = "A content uploader for GROWI";
-var type = "module";
-var bin = { "growi-uploader": "./dist/index.mjs" };
-var files = ["dist/**/*"];
-var scripts = {
-	"build": "pnpm gen && tsdown",
-	"prepublishOnly": "pnpm run build",
-	"dev": "tsx src/index.ts",
-	"gen": "orval",
-	"lint": "eslint .",
-	"typecheck": "tsc --noEmit",
-	"check": "pnpm run lint && pnpm run typecheck",
-	"format": "prettier --write src/"
-};
-var repository = {
-	"type": "git",
-	"url": "git+https://github.com/onozaty/growi-uploader.git"
-};
-var keywords = ["growi", "uploader"];
-var author = "onozaty";
-var license = "MIT";
-var bugs = { "url": "https://github.com/onozaty/growi-uploader/issues" };
-var homepage = "https://github.com/onozaty/growi-uploader#readme";
-var packageManager = "pnpm@10.12.1";
-var devDependencies = {
-	"@eslint/js": "^9.37.0",
-	"@types/mime-types": "^3.0.1",
-	"@types/node": "^24.7.2",
-	"eslint": "^9.37.0",
-	"globals": "^16.4.0",
-	"jiti": "^2.6.1",
-	"orval": "^7.13.2",
-	"prettier": "^3.6.2",
-	"tsdown": "^0.15.7",
-	"tsx": "^4.20.6",
-	"typescript": "^5.9.3",
-	"typescript-eslint": "^8.46.1"
-};
-var dependencies = {
-	"axios": "^1.12.2",
-	"commander": "^14.0.1",
-	"glob": "^11.0.3",
-	"mime-types": "^3.0.1"
-};
-var package_default = {
-	name,
-	version,
-	description,
-	type,
-	bin,
-	files,
-	scripts,
-	repository,
-	keywords,
-	author,
-	license,
-	bugs,
-	homepage,
-	packageManager,
-	devDependencies,
-	dependencies
+const replaceMarkdownExtension = (markdown, basePath = "/") => {
+	const result = markdown.replace(/(\[[^\]]*\]\((?!https?:\/\/))([^)]*?)\.md((?:#[^)]*)?\))/g, (match, prefix, path, suffix) => {
+		if (path.startsWith("/") && basePath !== "/") return `${prefix}${basePath.endsWith("/") ? basePath.slice(0, -1) : basePath}${path}${suffix}`;
+		return `${prefix}${path}${suffix}`;
+	});
+	return {
+		content: result,
+		replaced: result !== markdown
+	};
 };
 
 //#endregion
-//#region src/index.ts
-const program = new Command();
-program.name("growi-uploader").description("A content uploader for GROWI").version(package_default.version).argument("<source-dir>", "Source directory containing Markdown files").option("-c, --config <path>", "Path to config file", "growi-uploader.json").action(async (sourceDir, options) => {
-	try {
-		const config = loadConfig(options.config);
-		const sourceDirPath = resolve(sourceDir);
-		configureAxios(config.url, config.token);
-		const files$1 = await scanMarkdownFiles(sourceDirPath, config.basePath);
-		const totalAttachments = files$1.reduce((sum, file) => sum + file.attachments.length, 0);
-		console.log(`Found ${files$1.length} Markdown file(s) and ${totalAttachments} attachment(s)\n`);
-		let pagesCreated = 0;
-		let pagesUpdated = 0;
-		let pagesSkipped = 0;
-		let pageErrors = 0;
-		let attachmentsUploaded = 0;
-		let attachmentsSkipped = 0;
-		let attachmentErrors = 0;
-		for (const file of files$1) {
-			const result = await createOrUpdatePage(file, config);
-			if (result.action === "created") pagesCreated++;
-			else if (result.action === "updated") pagesUpdated++;
-			else if (result.action === "skipped") pagesSkipped++;
-			else if (result.action === "error") pageErrors++;
-			if (result.pageId && (result.action === "created" || result.action === "updated") && file.attachments.length > 0) {
+//#region src/uploader.ts
+/**
+* Upload Markdown files and their attachments to GROWI
+*
+* This function orchestrates a 4-stage upload process:
+* 1. Create or update page with original Markdown content
+* 2. Upload attachments
+* 3. Replace attachment links in Markdown and update page
+* 4. Replace .md extension in page links and update page
+*
+* @param files List of Markdown files to upload
+* @param sourceDir Source directory containing files
+* @param config Configuration (only update flag is used)
+* @returns Upload statistics
+*/
+const uploadFiles = async (files, sourceDir, config) => {
+	const stats = {
+		pagesCreated: 0,
+		pagesUpdated: 0,
+		pagesSkipped: 0,
+		pageErrors: 0,
+		attachmentsUploaded: 0,
+		attachmentsSkipped: 0,
+		attachmentErrors: 0,
+		linkReplacementErrors: 0
+	};
+	for (const file of files) {
+		const content = readFileSync(join(sourceDir, file.localPath), "utf-8");
+		const result = await createOrUpdatePage(file, content, config.update);
+		if (result.action === "created") {
+			stats.pagesCreated++;
+			console.log(`[SUCCESS] ${file.localPath} → ${file.growiPath} (created)`);
+		} else if (result.action === "updated") {
+			stats.pagesUpdated++;
+			console.log(`[SUCCESS] ${file.localPath} → ${file.growiPath} (updated)`);
+		} else if (result.action === "skipped") {
+			stats.pagesSkipped++;
+			console.log(`[SKIP] ${file.localPath} → ${file.growiPath} (page already exists)`);
+		} else if (result.action === "error") {
+			stats.pageErrors++;
+			console.error(`[ERROR] ${file.localPath} → ${file.growiPath} (${result.errorMessage || "unknown error"})`);
+		}
+		if (result.pageId && (result.action === "created" || result.action === "updated")) {
+			let currentContent = content;
+			let currentRevisionId = result.revisionId;
+			if (file.attachments.length > 0) {
 				let hasAttachments = false;
 				let latestRevisionId = result.revisionId;
 				for (const attachment of file.attachments) {
-					const attachmentResult = await uploadAttachment(attachment, result.pageId, file.growiPath, sourceDirPath);
+					const attachmentResult = await uploadAttachment(attachment, result.pageId, sourceDir);
 					if (attachmentResult.success) {
-						attachmentsUploaded++;
+						stats.attachmentsUploaded++;
+						console.log(`[SUCCESS] ${attachment.localPath} → ${file.growiPath} (attachment)`);
 						if (attachmentResult.attachmentId) {
 							attachment.attachmentId = attachmentResult.attachmentId;
 							hasAttachments = true;
 						}
 						if (attachmentResult.revisionId) latestRevisionId = attachmentResult.revisionId;
-					} else attachmentErrors++;
+					} else {
+						stats.attachmentErrors++;
+						console.error(`[ERROR] ${attachment.localPath} → ${file.growiPath} (${attachmentResult.errorMessage || "failed to upload attachment"})`);
+					}
 				}
 				if (hasAttachments && latestRevisionId) {
+					currentRevisionId = latestRevisionId;
 					const pageName = basename(file.localPath, ".md");
-					const { content: replacedContent, replaced } = replaceAttachmentLinks(file.content, file.attachments, pageName);
+					const { content: replacedContent, replaced } = replaceAttachmentLinks(currentContent, file.attachments, pageName);
 					if (replaced) {
-						if (await updatePageContent(result.pageId, latestRevisionId, replacedContent, file.growiPath)) console.log(`[SUCCESS] ${file.localPath} → ${file.growiPath} (attachment links replaced)`);
+						const updateResult = await updatePageContent(result.pageId, currentRevisionId, replacedContent);
+						if (updateResult.success && updateResult.revisionId) {
+							console.log(`[SUCCESS] ${file.localPath} → ${file.growiPath} (attachment links replaced)`);
+							currentContent = replacedContent;
+							currentRevisionId = updateResult.revisionId;
+						} else {
+							console.error(`[ERROR] ${file.localPath} → ${file.growiPath} (failed to update attachment links: ${updateResult.errorMessage || "unknown error"})`);
+							stats.linkReplacementErrors++;
+						}
+					}
+				}
+			}
+			if (currentRevisionId) {
+				const { content: linkedContent, replaced: linkReplaced } = replaceMarkdownExtension(currentContent, config.basePath);
+				if (linkReplaced) {
+					const updateResult = await updatePageContent(result.pageId, currentRevisionId, linkedContent);
+					if (updateResult.success && updateResult.revisionId) {
+						console.log(`[SUCCESS] ${file.localPath} → ${file.growiPath} (page links replaced)`);
+						currentRevisionId = updateResult.revisionId;
+					} else {
+						console.error(`[ERROR] ${file.localPath} → ${file.growiPath} (failed to update page links: ${updateResult.errorMessage || "unknown error"})`);
+						stats.linkReplacementErrors++;
 					}
 				}
-			} else if (file.attachments.length > 0) for (const attachment of file.attachments) {
-				console.log(`[SKIP] ${attachment.localPath} → ${file.growiPath} (attachment skipped)`);
-				attachmentsSkipped++;
 			}
+		} else if (file.attachments.length > 0) for (const attachment of file.attachments) {
+			console.log(`[SKIP] ${attachment.localPath} → ${file.growiPath} (attachment skipped)`);
+			stats.attachmentsSkipped++;
 		}
-		console.log("\nCompleted:");
-		console.log(`- Pages created: ${pagesCreated}`);
-		console.log(`- Pages updated: ${pagesUpdated}`);
-		console.log(`- Pages skipped: ${pagesSkipped}`);
-		console.log(`- Page errors: ${pageErrors}`);
-		console.log(`- Attachments uploaded: ${attachmentsUploaded}`);
-		console.log(`- Attachments skipped: ${attachmentsSkipped}`);
-		console.log(`- Attachment errors: ${attachmentErrors}`);
+	}
+	return stats;
+};
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+const main = async (sourceDir, configPath) => {
+	const config = loadConfig(configPath);
+	const sourceDirPath = resolve(sourceDir);
+	configureAxios(config.url, config.token);
+	const files = await scanMarkdownFiles(sourceDirPath, config.basePath);
+	const totalAttachments = files.reduce((sum, file) => sum + file.attachments.length, 0);
+	console.log(`Found ${files.length} Markdown file(s) and ${totalAttachments} attachment(s)\n`);
+	const stats = await uploadFiles(files, sourceDirPath, config);
+	console.log("\nCompleted:");
+	console.log(`- Pages created: ${stats.pagesCreated}`);
+	console.log(`- Pages updated: ${stats.pagesUpdated}`);
+	console.log(`- Pages skipped: ${stats.pagesSkipped}`);
+	console.log(`- Page errors: ${stats.pageErrors}`);
+	console.log(`- Attachments uploaded: ${stats.attachmentsUploaded}`);
+	console.log(`- Attachments skipped: ${stats.attachmentsSkipped}`);
+	console.log(`- Attachment errors: ${stats.attachmentErrors}`);
+	console.log(`- Link replacement errors: ${stats.linkReplacementErrors}`);
+};
+program.name("growi-uploader").description("A content uploader for GROWI").version(version).argument("<source-dir>", "Source directory containing Markdown files").option("-c, --config <path>", "Path to config file", "growi-uploader.json").action(async (sourceDir, options) => {
+	try {
+		await main(sourceDir, options.config);
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
 		process.exit(1);
 	}
 });
-program.parse();
+if (process.env.NODE_ENV !== "test" && !process.env.VITEST) program.parse();
 
 //#endregion
-export {  };
+export { main };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onozaty/growi-uploader",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "A content uploader for GROWI",
   "type": "module",
   "bin": {
@@ -17,7 +17,9 @@
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
     "check": "pnpm run lint && pnpm run typecheck",
-    "format": "prettier --write src/"
+    "format": "prettier --write src/",
+    "test": "vitest run",
+    "test:cov": "vitest run --coverage"
   },
   "repository": {
     "type": "git",
@@ -38,15 +40,18 @@
     "@eslint/js": "^9.37.0",
     "@types/mime-types": "^3.0.1",
     "@types/node": "^24.7.2",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/eslint-plugin": "^1.3.23",
     "eslint": "^9.37.0",
     "globals": "^16.4.0",
     "jiti": "^2.6.1",
     "orval": "^7.13.2",
     "prettier": "^3.6.2",
-    "tsdown": "^0.15.7",
+    "tsdown": "^0.15.9",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.1"
+    "typescript-eslint": "^8.46.1",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "axios": "^1.12.2",