krx-cli 1.3.1 → 1.6.0

package/dist/mcp.js

@@ -6,9 +6,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -2984,7 +2981,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -3011,7 +3008,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3226,8 +3223,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path3) {
-      let input = path3;
+    function removeDotSegments(path5) {
+      let input = path5;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3426,8 +3423,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path3, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
+        const [path5, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path5 && path5 !== "/" ? path5 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3586,7 +3583,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3813,7 +3810,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -6789,12 +6786,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs3, exportName) {
+    function addFormats(ajv, list, fs5, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs3[f]);
+        ajv.addFormat(f, fs5[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6802,72 +6799,6 @@ var require_dist = __commonJS({
   }
 });
 
-// src/client/rate-limit.ts
-var rate_limit_exports = {};
-__export(rate_limit_exports, {
-  checkRateLimit: () => checkRateLimit,
-  getRateLimitStatus: () => getRateLimitStatus,
-  incrementCallCount: () => incrementCallCount
-});
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-function today() {
-  const now = /* @__PURE__ */ new Date();
-  const yyyy = now.getFullYear().toString();
-  const mm = (now.getMonth() + 1).toString().padStart(2, "0");
-  const dd = now.getDate().toString().padStart(2, "0");
-  return `${yyyy}${mm}${dd}`;
-}
-function readRateData() {
-  try {
-    const raw = fs.readFileSync(RATE_FILE, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return { date: today(), count: 0 };
-  }
-}
-function writeRateData(data) {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs.writeFileSync(RATE_FILE, JSON.stringify(data, null, 2), "utf-8");
-}
-function incrementCallCount() {
-  const data = readRateData();
-  const currentDate = today();
-  const newData = data.date === currentDate ? { date: currentDate, count: data.count + 1 } : { date: currentDate, count: 1 };
-  writeRateData(newData);
-  return { count: newData.count, limit: DAILY_LIMIT };
-}
-function checkRateLimit() {
-  const data = readRateData();
-  const currentDate = today();
-  const count = data.date === currentDate ? data.count : 0;
-  const allowed = count < DAILY_LIMIT;
-  const warning = count >= DAILY_LIMIT * WARNING_THRESHOLD;
-  return { allowed, count, limit: DAILY_LIMIT, warning };
-}
-function getRateLimitStatus() {
-  const data = readRateData();
-  const currentDate = today();
-  const count = data.date === currentDate ? data.count : 0;
-  return {
-    date: currentDate,
-    count,
-    limit: DAILY_LIMIT,
-    remaining: DAILY_LIMIT - count
-  };
-}
-var CONFIG_DIR, RATE_FILE, DAILY_LIMIT, WARNING_THRESHOLD;
-var init_rate_limit = __esm({
-  "src/client/rate-limit.ts"() {
-    "use strict";
-    CONFIG_DIR = path.join(os.homedir(), ".krx-cli");
-    RATE_FILE = path.join(CONFIG_DIR, "rate-limit.json");
-    DAILY_LIMIT = 1e4;
-    WARNING_THRESHOLD = 0.8;
-  }
-});
-
 // node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process3 from "node:process";
 
@@ -7638,10 +7569,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8024,11 +7955,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -8211,7 +8142,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path3 = []) => {
+  const processError = (error49, path5 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8221,7 +8152,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8253,8 +8184,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -20231,13 +20162,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path5 = ref.slice(1).split("/").filter(Boolean);
+  if (path5.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path5[0] === defsKey) {
+    const key = path5[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -22235,12 +22166,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -22605,8 +22536,8 @@ function getErrorMap2() {
 
 // node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path5, errorMaps, issueData } = params;
+  const fullPath = [...path5, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -22721,11 +22652,11 @@ var errorUtil;
 
 // node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path5, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path5;
     this._key = key;
   }
   get path() {
@@ -28135,7 +28066,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error48) {
@@ -28152,7 +28083,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error48) => {
         reject(error48);
       };
@@ -28230,7 +28161,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error48) {
           reject(error48);
@@ -28491,12 +28422,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -29596,7 +29527,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -30547,13 +30478,13 @@ var CATEGORIES = [
     probeEndpoint: "/svc/apis/esg/esg_index_info"
   }
 ];
-function ep(path3, description, descriptionKo, category) {
+function ep(path5, description, descriptionKo, category) {
   return {
-    path: path3,
+    path: path5,
     description,
     descriptionKo,
     category,
-    responseFields: RESPONSE_FIELDS[path3] ?? []
+    responseFields: RESPONSE_FIELDS[path5] ?? []
   };
 }
 var ENDPOINTS = [
@@ -30742,11 +30673,210 @@ var ENDPOINTS = [
   ep("/svc/apis/esg/esg_index_info", "ESG index info", "ESG \uC9C0\uC218 \uC815\uBCF4", "esg")
 ];
 
+// src/cache/store.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+
+// src/utils/date.ts
+function formatDateToYYYYMMDD(date5) {
+  const yyyy = date5.getFullYear().toString();
+  const mm = (date5.getMonth() + 1).toString().padStart(2, "0");
+  const dd = date5.getDate().toString().padStart(2, "0");
+  return `${yyyy}${mm}${dd}`;
+}
+function isWeekend(date5) {
+  const day = date5.getDay();
+  return day === 0 || day === 6;
+}
+var KST_OFFSET_MS = 9 * 60 * 60 * 1e3;
+function getRecentTradingDate() {
+  const nowKst = new Date(Date.now() + KST_OFFSET_MS);
+  const day = nowKst.getUTCDay();
+  const daysBack = day === 0 ? 2 : day === 6 ? 1 : day === 1 ? 3 : 1;
+  const targetKst = new Date(nowKst.getTime() - daysBack * 24 * 60 * 60 * 1e3);
+  const yyyy = targetKst.getUTCFullYear().toString();
+  const mm = (targetKst.getUTCMonth() + 1).toString().padStart(2, "0");
+  const dd = targetKst.getUTCDate().toString().padStart(2, "0");
+  return `${yyyy}${mm}${dd}`;
+}
+function parseYYYYMMDD(str) {
+  const year = parseInt(str.substring(0, 4));
+  const month = parseInt(str.substring(4, 6)) - 1;
+  const day = parseInt(str.substring(6, 8));
+  return new Date(year, month, day);
+}
+function getTradingDays(from, to) {
+  const fromDate = parseYYYYMMDD(from);
+  const toDate = parseYYYYMMDD(to);
+  const days = [];
+  let current = new Date(fromDate);
+  while (current <= toDate) {
+    if (!isWeekend(current)) {
+      days.push(formatDateToYYYYMMDD(current));
+    }
+    current = new Date(current.getTime() + 24 * 60 * 60 * 1e3);
+  }
+  return days;
+}
+
+// src/cache/store.ts
+var CACHE_DIR = path.join(os.homedir(), ".krx-cli", "cache");
+var DATE_FORMAT = /^\d{8}$/;
+function isValidCacheDate(date5) {
+  return DATE_FORMAT.test(date5);
+}
+function getCacheKey(endpoint, params) {
+  const sortedEntries = Object.entries(params).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const raw = `${endpoint}:${JSON.stringify(sortedEntries)}`;
+  return crypto.createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+function getCachePath(date5, key) {
+  return path.join(CACHE_DIR, date5, `${key}.json`);
+}
+function isToday(dateStr) {
+  const today2 = formatDateToYYYYMMDD(/* @__PURE__ */ new Date());
+  return dateStr === today2;
+}
+function getCached(endpoint, params) {
+  const date5 = params["basDd"];
+  if (!date5 || !isValidCacheDate(date5) || isToday(date5)) {
+    return null;
+  }
+  const key = getCacheKey(endpoint, params);
+  const cachePath = getCachePath(date5, key);
+  try {
+    const raw = fs.readFileSync(cachePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("ENOENT")) {
+      return null;
+    }
+    process.stderr.write(`[krx-cli] cache read failed: ${String(err)}
+`);
+    return null;
+  }
+}
+function setCached(endpoint, params, data) {
+  const date5 = params["basDd"];
+  if (!date5 || !isValidCacheDate(date5) || isToday(date5)) {
+    return;
+  }
+  const key = getCacheKey(endpoint, params);
+  const cachePath = getCachePath(date5, key);
+  const dir = path.dirname(cachePath);
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(cachePath, JSON.stringify(data), "utf-8");
+  } catch (err) {
+    process.stderr.write(`[krx-cli] cache write failed: ${String(err)}
+`);
+  }
+}
+
+// src/client/rate-limit.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import * as os2 from "node:os";
+var CONFIG_DIR = path2.join(os2.homedir(), ".krx-cli");
+var RATE_FILE = path2.join(CONFIG_DIR, "rate-limit.json");
+var DAILY_LIMIT = 1e4;
+var WARNING_THRESHOLD = 0.8;
+function today() {
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = now.getFullYear().toString();
+  const mm = (now.getMonth() + 1).toString().padStart(2, "0");
+  const dd = now.getDate().toString().padStart(2, "0");
+  return `${yyyy}${mm}${dd}`;
+}
+function readRateData() {
+  try {
+    const raw = fs2.readFileSync(RATE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { date: today(), count: 0 };
+  }
+}
+function writeRateData(data) {
+  fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs2.writeFileSync(RATE_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+function incrementCallCount() {
+  const data = readRateData();
+  const currentDate = today();
+  const newData = data.date === currentDate ? { date: currentDate, count: data.count + 1 } : { date: currentDate, count: 1 };
+  writeRateData(newData);
+  return { count: newData.count, limit: DAILY_LIMIT };
+}
+function checkRateLimit() {
+  const data = readRateData();
+  const currentDate = today();
+  const count = data.date === currentDate ? data.count : 0;
+  const allowed = count < DAILY_LIMIT;
+  const warning = count >= DAILY_LIMIT * WARNING_THRESHOLD;
+  return { allowed, count, limit: DAILY_LIMIT, warning };
+}
+function getRateLimitStatus() {
+  const data = readRateData();
+  const currentDate = today();
+  const count = data.date === currentDate ? data.count : 0;
+  return {
+    date: currentDate,
+    count,
+    limit: DAILY_LIMIT,
+    remaining: DAILY_LIMIT - count
+  };
+}
+
+// src/client/retry.ts
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BASE_DELAY = 1e3;
+function isNetworkError(error48) {
+  if (error48 instanceof TypeError) {
+    return true;
+  }
+  if (error48 instanceof Error) {
+    const msg = error48.message.toLowerCase();
+    return msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("network");
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function withRetry(fn, options) {
+  const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const baseDelay = options?.baseDelay ?? DEFAULT_BASE_DELAY;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isNetworkError(err) || attempt === maxRetries) {
+        throw err;
+      }
+      const waitMs = baseDelay * Math.pow(2, attempt);
+      await delay(waitMs);
+    }
+  }
+  throw lastError;
+}
+
 // src/client/client.ts
 var BASE_URL = "https://data-dbg.krx.co.kr";
 async function krxFetch(options) {
-  const { checkRateLimit: checkRateLimit2, incrementCallCount: incrementCallCount2 } = await Promise.resolve().then(() => (init_rate_limit(), rate_limit_exports));
-  const rateStatus = checkRateLimit2();
+  const useCache = options.cache !== false;
+  if (useCache) {
+    const cached2 = getCached(options.endpoint, options.params);
+    if (cached2) {
+      return { success: true, data: cached2 };
+    }
+  }
+  const rateStatus = checkRateLimit();
   if (!rateStatus.allowed) {
     return {
       success: false,
@@ -30762,15 +30892,18 @@ async function krxFetch(options) {
     );
   }
   const url2 = `${BASE_URL}${options.endpoint}`;
-  const response = await fetch(url2, {
-    method: "POST",
-    headers: {
-      AUTH_KEY: options.apiKey,
-      "Content-Type": "application/json; charset=utf-8"
-    },
-    body: JSON.stringify(options.params)
-  });
-  incrementCallCount2();
+  const response = await withRetry(
+    () => fetch(url2, {
+      method: "POST",
+      headers: {
+        AUTH_KEY: options.apiKey,
+        "Content-Type": "application/json; charset=utf-8"
+      },
+      body: JSON.stringify(options.params)
+    }),
+    { maxRetries: options.retries ?? 3 }
+  );
+  incrementCallCount();
   if (!response.ok) {
     let errorMsg = `HTTP ${response.status}: ${response.statusText}`;
     let errorCode;
@@ -30798,21 +30931,95 @@ async function krxFetch(options) {
       error: "Unexpected response format: missing OutBlock_1"
     };
   }
+  if (useCache) {
+    setCached(options.endpoint, options.params, outBlock);
+  }
   return {
     success: true,
     data: outBlock
   };
 }
 
+// src/client/range-fetch.ts
+var DEFAULT_CONCURRENCY = 5;
+async function fetchWithConcurrency(tasks, concurrency) {
+  const slots = new Array(tasks.length);
+  let index = 0;
+  async function runNext() {
+    while (index < tasks.length) {
+      const currentIndex = index;
+      index += 1;
+      const task = tasks[currentIndex];
+      if (task) {
+        const result = await task();
+        slots[currentIndex] = Promise.resolve(result);
+      }
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(concurrency, tasks.length) },
+    () => runNext()
+  );
+  await Promise.all(workers);
+  return Promise.all(slots);
+}
+async function fetchDateRange(options) {
+  const { endpoint, from, to, apiKey, cache, extraParams } = options;
+  const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+  if (from > to) {
+    return {
+      success: false,
+      data: [],
+      error: `'from' date (${from}) must not be after 'to' date (${to})`,
+      fetchedDays: 0,
+      failedDays: 0
+    };
+  }
+  const tradingDays = getTradingDays(from, to);
+  if (tradingDays.length === 0) {
+    return { success: true, data: [], fetchedDays: 0, failedDays: 0 };
+  }
+  const tasks = tradingDays.map((day) => async () => {
+    const params = {
+      basDd: day,
+      ...extraParams
+    };
+    return krxFetch({
+      endpoint,
+      params,
+      apiKey,
+      cache
+    });
+  });
+  const results = await fetchWithConcurrency(tasks, concurrency);
+  const failedDays = results.filter((r) => !r.success).length;
+  const mergedData = results.filter((r) => r.success).flatMap((r) => [...r.data]);
+  if (mergedData.length === 0 && failedDays > 0) {
+    return {
+      success: false,
+      data: [],
+      error: `All ${failedDays} trading day(s) failed to fetch`,
+      fetchedDays: 0,
+      failedDays
+    };
+  }
+  return {
+    success: true,
+    data: mergedData,
+    fetchedDays: tradingDays.length - failedDays,
+    failedDays
+  };
+}
+
 // src/client/auth.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import * as os2 from "node:os";
-var CONFIG_DIR2 = path2.join(os2.homedir(), ".krx-cli");
-var CONFIG_FILE = path2.join(CONFIG_DIR2, "config.json");
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import * as os3 from "node:os";
+var CONFIG_DIR2 = path3.join(os3.homedir(), ".krx-cli");
+var CONFIG_FILE = path3.join(CONFIG_DIR2, "config.json");
 function readConfig() {
   try {
-    const raw = fs2.readFileSync(CONFIG_FILE, "utf-8");
+    const raw = fs3.readFileSync(CONFIG_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -30821,6 +31028,9 @@ function readConfig() {
 function getApiKey() {
   return process.env["KRX_API_KEY"] ?? readConfig().apiKey;
 }
+function getCachedServiceStatus() {
+  return readConfig().serviceStatus ?? {};
+}
 
 // src/validator/index.ts
 var DATE_PATTERN = /^\d{8}$/;
@@ -30846,9 +31056,116 @@ function validateDate(value) {
   return result.data;
 }
 
+// src/utils/krx-number.ts
+function parseKrxNumber(value) {
+  const cleaned = value.replace(/,/g, "");
+  const num = parseFloat(cleaned);
+  return isNaN(num) ? 0 : num;
+}
+function isKrxNumericString(value) {
+  return /^-?[\d,]+\.?\d*$/.test(value.trim());
+}
+
+// src/utils/filter.ts
+var OPERATOR_PATTERN = /^(\S+)\s+(>=|<=|==|!=|>|<)\s+(.+)$/;
+function parseFilterExpression(expression) {
+  const trimmed = expression.trim().replace(/\s+/g, " ");
+  const match = OPERATOR_PATTERN.exec(trimmed);
+  if (!match || !match[1] || !match[2] || !match[3]) {
+    return null;
+  }
+  return {
+    field: match[1],
+    operator: match[2],
+    value: match[3].trim()
+  };
+}
+function compareValues(fieldValue, operator, filterValue) {
+  const isNumeric = isKrxNumericString(fieldValue) && isKrxNumericString(filterValue);
+  if (isNumeric) {
+    const a = parseKrxNumber(fieldValue);
+    const b = parseKrxNumber(filterValue);
+    switch (operator) {
+      case ">":
+        return a > b;
+      case "<":
+        return a < b;
+      case ">=":
+        return a >= b;
+      case "<=":
+        return a <= b;
+      case "==":
+        return a === b;
+      case "!=":
+        return a !== b;
+    }
+  }
+  switch (operator) {
+    case "==":
+      return fieldValue === filterValue;
+    case "!=":
+      return fieldValue !== filterValue;
+    case ">":
+      return fieldValue > filterValue;
+    case "<":
+      return fieldValue < filterValue;
+    case ">=":
+      return fieldValue >= filterValue;
+    case "<=":
+      return fieldValue <= filterValue;
+    default: {
+      const _exhaustive = operator;
+      void _exhaustive;
+      return false;
+    }
+  }
+}
+function filterData(data, expression) {
+  const parsed = parseFilterExpression(expression);
+  if (!parsed) {
+    return data;
+  }
+  return data.filter((row) => {
+    const fieldValue = row[parsed.field];
+    if (fieldValue === void 0 || fieldValue === null) {
+      return false;
+    }
+    return compareValues(String(fieldValue), parsed.operator, parsed.value);
+  });
+}
+
+// src/utils/data-pipeline.ts
+function sortData(data, field, direction = "desc") {
+  const sorted = [...data].sort((a, b) => {
+    const aVal = String(a[field] ?? "");
+    const bVal = String(b[field] ?? "");
+    if (isKrxNumericString(aVal) && isKrxNumericString(bVal)) {
+      return parseKrxNumber(aVal) - parseKrxNumber(bVal);
+    }
+    return aVal.localeCompare(bVal, "ko");
+  });
+  return direction === "desc" ? sorted.reverse() : sorted;
+}
+function limitData(data, limit) {
+  return data.slice(0, limit);
+}
+function applyPipeline(data, options) {
+  let result = data;
+  if (options.filter) {
+    result = filterData(result, options.filter);
+  }
+  if (options.sort) {
+    result = sortData(result, options.sort, options.direction ?? "desc");
+  }
+  if (options.limit && options.limit > 0) {
+    result = limitData(result, options.limit);
+  }
+  return result;
+}
+
 // src/mcp/tools/index.ts
-function getEndpointShortName(path3) {
-  return path3.split("/").pop() ?? path3;
+function getEndpointShortName(path5) {
+  return path5.split("/").pop() ?? path5;
 }
 function buildDescription(categoryId, endpoints) {
   const category = CATEGORIES.find((c) => c.id === categoryId);
@@ -30874,6 +31191,19 @@ function buildInputSchema(endpoints) {
     date: external_exports.string().optional().describe(
       "Trading date in YYYYMMDD format (default: recent trading day)"
     ),
+    date_from: external_exports.string().optional().describe(
+      "Start date for range query (YYYYMMDD). Use with date_to for multi-day data."
+    ),
+    date_to: external_exports.string().optional().describe(
+      "End date for range query (YYYYMMDD). Use with date_from for multi-day data."
+    ),
+    isuCd: external_exports.string().optional().describe("Stock/item code (ISU_CD) to filter a specific item"),
+    sort: external_exports.string().optional().describe("Sort results by this field name"),
+    sort_direction: external_exports.enum(["asc", "desc"]).optional().describe("Sort direction (default: desc)"),
+    limit: external_exports.number().optional().describe("Limit number of results returned"),
+    filter: external_exports.string().optional().describe(
+      'Filter expression (e.g. "FLUC_RT > 5", "MKT_NM == KOSPI"). Operators: >, <, >=, <=, ==, !='
+    ),
     fields: external_exports.array(external_exports.string()).optional().describe("Filter response to these field names only")
   };
 }
@@ -30892,16 +31222,6 @@ function filterFields(data, fields) {
     return filtered;
   });
 }
-function getRecentTradingDate() {
-  const now = /* @__PURE__ */ new Date();
-  const day = now.getDay();
-  const daysBack = day === 0 ? 2 : day === 6 ? 1 : day === 1 ? 3 : 1;
-  const target = new Date(now.getTime() - daysBack * 24 * 60 * 60 * 1e3);
-  const yyyy = target.getFullYear().toString();
-  const mm = (target.getMonth() + 1).toString().padStart(2, "0");
-  const dd = target.getDate().toString().padStart(2, "0");
-  return `${yyyy}${mm}${dd}`;
-}
 function errorResult(message) {
   return {
     content: [
@@ -30930,6 +31250,59 @@ function createCategoryTool(categoryId) {
       if (!endpoint) {
         return errorResult(`Unknown endpoint: ${shortName}`);
       }
+      const dateFrom = args.date_from;
+      const dateTo = args.date_to;
+      const isuCd = args.isuCd;
+      if (dateFrom && !dateTo || !dateFrom && dateTo) {
+        return errorResult(
+          "Both date_from and date_to must be provided together"
+        );
+      }
+      const isDateRange = dateFrom && dateTo;
+      if (isDateRange) {
+        try {
+          validateDate(dateFrom);
+          validateDate(dateTo);
+        } catch (err) {
+          return errorResult(
+            err instanceof Error ? err.message : "Invalid date format"
+          );
+        }
+        const extraParams = {};
+        if (isuCd) {
+          extraParams["isuCd"] = isuCd;
+        }
+        const rangeResult = await fetchDateRange({
+          endpoint: endpoint.path,
+          from: dateFrom,
+          to: dateTo,
+          apiKey,
+          extraParams
+        });
+        if (!rangeResult.success) {
+          return errorResult(rangeResult.error ?? "Date range fetch failed");
+        }
+        let data2 = rangeResult.data;
+        const filterExpr = args.filter;
+        const sortField2 = args.sort;
+        const sortDirection2 = args.sort_direction ?? "desc";
+        const limitN2 = args.limit;
+        data2 = applyPipeline(data2, {
+          filter: filterExpr,
+          sort: sortField2,
+          direction: sortDirection2,
+          limit: limitN2
+        });
+        const fields2 = args.fields;
+        if (fields2) {
+          data2 = filterFields(data2, fields2);
+        }
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(data2, null, 2) }
+          ]
+        };
+      }
       const dateStr = args.date ?? getRecentTradingDate();
       try {
         validateDate(dateStr);
@@ -30938,16 +31311,33 @@ function createCategoryTool(categoryId) {
           err instanceof Error ? err.message : "Invalid date format"
         );
       }
+      const params = { basDd: dateStr };
+      if (isuCd) {
+        params["isuCd"] = isuCd;
+      }
       const result = await krxFetch({
         endpoint: endpoint.path,
-        params: { basDd: dateStr },
+        params,
         apiKey
       });
       if (!result.success) {
         return errorResult(result.error ?? "API request failed");
       }
+      const filterExpr2 = args.filter;
+      const sortField = args.sort;
+      const sortDirection = args.sort_direction ?? "desc";
+      const limitN = args.limit;
+      let data = result.data;
+      data = applyPipeline(data, {
+        filter: filterExpr2,
+        sort: sortField,
+        direction: sortDirection,
+        limit: limitN
+      });
       const fields = args.fields;
-      const data = fields ? filterFields(result.data, fields) : result.data;
+      if (fields) {
+        data = filterFields(data, fields);
+      }
       return {
         content: [
           { type: "text", text: JSON.stringify(data, null, 2) }
@@ -30961,8 +31351,8 @@ function createCategoryTools() {
 }
 
 // src/mcp/tools/schema-tool.ts
-function getEndpointShortName2(path3) {
-  return path3.split("/").pop() ?? path3;
+function getEndpointShortName2(path5) {
+  return path5.split("/").pop() ?? path5;
 }
 function createSchemaTool() {
   const allShortNames = ENDPOINTS.map((e) => getEndpointShortName2(e.path));
@@ -31023,7 +31413,6 @@ function createSchemaTool() {
 }
 
 // src/mcp/tools/rate-limit-tool.ts
-init_rate_limit();
 function createRateLimitTool() {
   return {
     name: "krx_rate_limit",
@@ -31040,22 +31429,591 @@ function createRateLimitTool() {
   };
 }
 
+// src/client/search.ts
+var BASE_INFO_ENDPOINTS = [
+  { endpoint: "/svc/apis/sto/stk_isu_base_info", market: "KOSPI" },
+  { endpoint: "/svc/apis/sto/ksq_isu_base_info", market: "KOSDAQ" }
+];
+async function searchStock(apiKey, query) {
+  const basDd = getRecentTradingDate();
+  const lowerQuery = query.toLowerCase();
+  const results = await Promise.all(
+    BASE_INFO_ENDPOINTS.map(async ({ endpoint, market }) => {
+      const result = await krxFetch({
+        endpoint,
+        params: { basDd },
+        apiKey
+      });
+      if (!result.success) {
+        return [];
+      }
+      return result.data.filter((row) => {
+        const name = row["ISU_NM"] ?? "";
+        const shortName = row["ISU_ABBRV"] ?? "";
+        return name.toLowerCase().includes(lowerQuery) || shortName.toLowerCase().includes(lowerQuery);
+      }).map((row) => ({
+        ISU_CD: row["ISU_CD"] ?? "",
+        ISU_SRT_CD: row["ISU_SRT_CD"] ?? "",
+        ISU_NM: row["ISU_NM"] ?? row["ISU_ABBRV"] ?? "",
+        MKT_NM: market
+      }));
+    })
+  );
+  return results.flat();
+}
+
+// src/mcp/tools/search-tool.ts
+function createSearchTool() {
+  return {
+    name: "krx_search",
+    description: "Search KRX stocks by name. Returns matching stock codes (ISU_CD), short codes (ISU_SRT_CD), names (ISU_NM), and market (KOSPI/KOSDAQ). Use this to resolve a stock name to its code before querying market data.",
+    inputSchema: {
+      query: external_exports.string().describe(
+        "Stock name or partial name to search (e.g., '\uC0BC\uC131\uC804\uC790', '\uCE74\uCE74\uC624')"
+      )
+    },
+    handler: async (args) => {
+      const query = args.query;
+      const apiKey = getApiKey();
+      if (!apiKey) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "API key not configured. Set KRX_API_KEY environment variable."
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const results = await searchStock(apiKey, query);
+      if (results.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `No stocks found matching "${query}"`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(results, null, 2) }
+        ]
+      };
+    }
+  };
+}
+
+// src/client/market-summary.ts
+var KOSPI_INDEX_ENDPOINT = "/svc/apis/idx/kospi_dd_trd";
+var KOSDAQ_INDEX_ENDPOINT = "/svc/apis/idx/kosdaq_dd_trd";
+var KOSPI_STOCK_ENDPOINT = "/svc/apis/sto/stk_bydd_trd";
+var KOSDAQ_STOCK_ENDPOINT = "/svc/apis/sto/ksq_bydd_trd";
+var TOP_N = 5;
+function computeStockStats(stocks) {
+  return stocks.reduce(
+    (acc, stock) => {
+      const rate = parseKrxNumber(stock["FLUC_RT"] ?? "0");
+      return {
+        advancing: acc.advancing + (rate > 0 ? 1 : 0),
+        declining: acc.declining + (rate < 0 ? 1 : 0),
+        unchanged: acc.unchanged + (rate === 0 ? 1 : 0),
+        totalVolume: acc.totalVolume + parseKrxNumber(stock["ACC_TRDVOL"] ?? "0"),
+        totalValue: acc.totalValue + parseKrxNumber(stock["ACC_TRDVAL"] ?? "0")
+      };
+    },
+    {
+      advancing: 0,
+      declining: 0,
+      unchanged: 0,
+      totalVolume: 0,
+      totalValue: 0
+    }
+  );
+}
+function computeTopMovers(stocks) {
+  const sorted = [...stocks].sort((a, b) => {
+    const rateA = parseKrxNumber(a["FLUC_RT"] ?? "0");
+    const rateB = parseKrxNumber(b["FLUC_RT"] ?? "0");
+    return rateB - rateA;
+  });
+  const topGainers = sorted.slice(0, TOP_N);
+  const topLosers = sorted.slice(-TOP_N).reverse();
+  return { topGainers, topLosers };
+}
+function safeFetch(...args) {
+  return krxFetch(...args).catch(
+    (err) => ({
+      success: false,
+      data: [],
+      error: err instanceof Error ? err.message : "Network error"
+    })
+  );
+}
+async function fetchMarketSummary(options) {
+  const { apiKey, date: date5, cache } = options;
+  const params = { basDd: date5 };
+  const [kospiIdx, kosdaqIdx, kospiStk, kosdaqStk] = await Promise.all([
+    safeFetch({ endpoint: KOSPI_INDEX_ENDPOINT, params, apiKey, cache }),
+    safeFetch({ endpoint: KOSDAQ_INDEX_ENDPOINT, params, apiKey, cache }),
+    safeFetch({ endpoint: KOSPI_STOCK_ENDPOINT, params, apiKey, cache }),
+    safeFetch({ endpoint: KOSDAQ_STOCK_ENDPOINT, params, apiKey, cache })
+  ]);
+  const allFailed = !kospiIdx.success && !kosdaqIdx.success && !kospiStk.success && !kosdaqStk.success;
+  if (allFailed) {
+    return {
+      success: false,
+      error: "All market data fetches failed"
+    };
+  }
+  const kospiIndexData = kospiIdx.success ? kospiIdx.data : [];
+  const kosdaqIndexData = kosdaqIdx.success ? kosdaqIdx.data : [];
+  const kospiStockData = kospiStk.success ? kospiStk.data : [];
+  const kosdaqStockData = kosdaqStk.success ? kosdaqStk.data : [];
+  const allStocks = [...kospiStockData, ...kosdaqStockData];
+  const stockStats = computeStockStats(allStocks);
+  const { topGainers, topLosers } = computeTopMovers(allStocks);
+  return {
+    success: true,
+    data: {
+      date: date5,
+      kospiIndex: kospiIndexData,
+      kosdaqIndex: kosdaqIndexData,
+      stockStats,
+      topGainers,
+      topLosers
+    }
+  };
+}
+
+// src/mcp/tools/market-summary-tool.ts
+function createMarketSummaryTool() {
+  return {
+    name: "krx_market_summary",
+    description: `Get a comprehensive market summary including KOSPI/KOSDAQ indices, stock statistics (advancing/declining/unchanged), top 5 gainers/losers, and total trading volume/value.
+
+This tool combines data from 4 API endpoints in a single call \u2014 ideal for getting a quick market overview.
+
+Returns:
+- kospiIndex: KOSPI series index data
+- kosdaqIndex: KOSDAQ series index data
+- stockStats: { advancing, declining, unchanged, totalVolume, totalValue }
+- topGainers: Top 5 stocks by change rate
+- topLosers: Bottom 5 stocks by change rate`,
+    inputSchema: {
+      date: external_exports.string().optional().describe(
+        "Trading date in YYYYMMDD format (default: recent trading day)"
+      )
+    },
+    handler: async (args) => {
+      const apiKey = getApiKey();
+      if (!apiKey) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "API key not configured. Set KRX_API_KEY environment variable."
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const dateStr = args.date ?? getRecentTradingDate();
+      try {
+        validateDate(dateStr);
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: err instanceof Error ? err.message : "Invalid date"
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const result = await fetchMarketSummary({
+        apiKey,
+        date: dateStr
+      });
+      if (!result.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: result.error ?? "Failed to fetch market summary"
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2)
+          }
+        ]
+      };
+    }
+  };
+}
+
+// src/watchlist/store.ts
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+import * as os4 from "node:os";
+function getWatchlistPath() {
+  return path4.join(os4.homedir(), ".krx-cli", "watchlist.json");
+}
+function getWatchlist() {
+  const filePath = getWatchlistPath();
+  if (!fs4.existsSync(filePath)) {
+    return [];
+  }
+  try {
+    const raw = fs4.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    process.stderr.write(`[krx-cli] watchlist read failed: ${String(err)}
+`);
+    return [];
+  }
+}
+function saveWatchlist(entries) {
+  const filePath = getWatchlistPath();
+  const dir = path4.dirname(filePath);
+  try {
+    fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(filePath, JSON.stringify(entries, null, 2), "utf-8");
+    return true;
+  } catch (err) {
+    process.stderr.write(`[krx-cli] watchlist write failed: ${String(err)}
+`);
+    return false;
+  }
+}
+function addToWatchlist(entry) {
+  const current = getWatchlist();
+  const isDuplicate = current.some((e) => e.isuCd === entry.isuCd);
+  if (isDuplicate) {
+    return { added: false, reason: "duplicate" };
+  }
+  const saved = saveWatchlist([...current, entry]);
+  return saved ? { added: true } : { added: false, reason: "write_error" };
+}
+function removeFromWatchlist(nameOrCode) {
+  const current = getWatchlist();
+  const filtered = current.filter(
+    (e) => e.isuCd !== nameOrCode && e.name !== nameOrCode
+  );
+  if (filtered.length === current.length) {
+    return { removed: false, reason: "not_found" };
+  }
+  const saved = saveWatchlist(filtered);
+  return saved ? { removed: true } : { removed: false, reason: "write_error" };
+}
+
+// src/mcp/tools/watchlist-tool.ts
+var STOCK_ENDPOINTS = {
+  KOSPI: "/svc/apis/sto/stk_bydd_trd",
+  KOSDAQ: "/svc/apis/sto/ksq_bydd_trd"
+};
+function textResult(data, isError = false) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    ...isError ? { isError: true } : {}
+  };
+}
+async function handleAdd(name) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    return textResult({ error: "API key not configured" }, true);
+  }
+  let results;
+  try {
+    results = await searchStock(apiKey, name);
+  } catch (err) {
+    return textResult(
+      {
+        error: `Search failed: ${err instanceof Error ? err.message : String(err)}`
+      },
+      true
+    );
+  }
+  if (results.length === 0) {
+    return textResult({ error: `No stock found matching '${name}'` }, true);
+  }
+  if (results.length > 1) {
+    return textResult({
+      message: `Multiple matches for '${name}'. Be more specific.`,
+      matches: results
+    });
+  }
+  const stock = results[0];
+  const result = addToWatchlist({
+    isuCd: stock.ISU_CD,
+    isuSrtCd: stock.ISU_SRT_CD,
+    name: stock.ISU_NM,
+    market: stock.MKT_NM
+  });
+  if (!result.added) {
+    const message = result.reason === "write_error" ? "Failed to save watchlist" : `'${stock.ISU_NM}' is already in watchlist`;
+    return textResult({ error: message }, result.reason === "write_error");
+  }
+  return textResult({
+    message: `Added '${stock.ISU_NM}' (${stock.ISU_CD})`,
+    entry: { isuCd: stock.ISU_CD, name: stock.ISU_NM, market: stock.MKT_NM }
+  });
+}
+async function handleShow(dateArg) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    return textResult({ error: "API key not configured" }, true);
+  }
+  const entries = getWatchlist();
+  if (entries.length === 0) {
+    return textResult({ message: "Watchlist is empty", entries: [] });
+  }
+  const date5 = dateArg ?? getRecentTradingDate();
+  try {
+    validateDate(date5);
+  } catch (err) {
+    return textResult(
+      { error: err instanceof Error ? err.message : "Invalid date" },
+      true
+    );
+  }
+  const isuCds = new Set(entries.map((e) => e.isuCd));
+  const errors = [];
+  const [kospiResult, kosdaqResult] = await Promise.all([
+    krxFetch({
+      endpoint: STOCK_ENDPOINTS.KOSPI,
+      params: { basDd: date5 },
+      apiKey
+    }).catch((err) => {
+      errors.push(`KOSPI: ${err instanceof Error ? err.message : String(err)}`);
+      return { success: false, data: [] };
+    }),
+    krxFetch({
+      endpoint: STOCK_ENDPOINTS.KOSDAQ,
+      params: { basDd: date5 },
+      apiKey
+    }).catch((err) => {
+      errors.push(
+        `KOSDAQ: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return { success: false, data: [] };
+    })
+  ]);
+  if (!kospiResult.success && !kosdaqResult.success) {
+    return textResult(
+      { error: `All market data fetches failed: ${errors.join("; ")}` },
+      true
+    );
+  }
+  const allStocks = [
+    ...kospiResult.success ? kospiResult.data : [],
+    ...kosdaqResult.success ? kosdaqResult.data : []
+  ];
+  const watchlistData = allStocks.filter((s) => isuCds.has(s["ISU_CD"] ?? ""));
+  const output = { date: date5, stocks: watchlistData };
+  if (errors.length > 0) {
+    output["warnings"] = errors;
+  }
+  return textResult(output);
+}
+function createWatchlistTool() {
+  return {
+    name: "krx_watchlist",
+    description: `Manage a persistent watchlist of stocks.
+
+Actions:
+- add: Search by name and add to watchlist
+- remove: Remove by name or stock code (exact match)
+- list: Show all watchlist entries
+- show: Fetch current prices for all watchlist stocks
+
+The watchlist is stored locally at ~/.krx-cli/watchlist.json.`,
+    inputSchema: {
+      action: external_exports.enum(["add", "remove", "list", "show"]).describe("Action to perform"),
+      name: external_exports.string().optional().describe("Stock name or code (required for add/remove)"),
+      date: external_exports.string().optional().describe("Trading date YYYYMMDD (for show action)")
+    },
+    handler: async (args) => {
+      const action = args.action;
+      const name = args.name;
+      const date5 = args.date;
+      switch (action) {
+        case "add": {
+          if (!name) {
+            return textResult(
+              { error: "name is required for add action" },
+              true
+            );
+          }
+          return handleAdd(name);
+        }
+        case "remove": {
+          if (!name) {
+            return textResult(
+              { error: "name is required for remove action" },
+              true
+            );
+          }
+          const result = removeFromWatchlist(name);
+          if (!result.removed) {
+            const message = result.reason === "write_error" ? "Failed to save watchlist" : `'${name}' not found in watchlist`;
+            return textResult({ error: message }, true);
+          }
+          return textResult({ message: `Removed '${name}' from watchlist` });
+        }
+        case "list": {
+          const entries = getWatchlist();
+          return textResult(
+            entries.length === 0 ? { message: "Watchlist is empty", entries: [] } : entries
+          );
+        }
+        case "show": {
+          return handleShow(date5);
+        }
+        default: {
+          return textResult({ error: `Unknown action: ${action}` }, true);
+        }
+      }
+    }
+  };
+}
+
+// src/mcp/resources/index.ts
+function jsonContent(uri, data) {
+  return {
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(data)
+      }
+    ]
+  };
+}
+function errorContent(uri, message) {
+  return jsonContent(uri, { error: message });
+}
+function createWatchlistResource() {
+  return {
+    name: "watchlist",
+    uri: "krx://watchlist",
+    handler: async (uri) => {
+      try {
+        const entries = getWatchlist();
+        return jsonContent(uri, entries);
+      } catch {
+        return errorContent(uri, "Failed to read watchlist");
+      }
+    }
+  };
+}
+function createRateLimitResource() {
+  return {
+    name: "rate-limit",
+    uri: "krx://rate-limit",
+    handler: async (uri) => {
+      try {
+        const status = getRateLimitStatus();
+        return jsonContent(uri, status);
+      } catch {
+        return errorContent(uri, "Failed to read rate limit status");
+      }
+    }
+  };
+}
+function createServiceStatusResource() {
+  return {
+    name: "service-status",
+    uri: "krx://service-status",
+    handler: async (uri) => {
+      try {
+        const rawStatus = getCachedServiceStatus();
+        const safeStatus = Object.fromEntries(
+          Object.entries(rawStatus).filter(([key]) => key !== "apiKey")
+        );
+        return jsonContent(uri, safeStatus);
+      } catch {
+        return errorContent(uri, "Failed to read service status");
+      }
+    }
+  };
+}
+
+// src/cli/commands/version.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname as dirname3, resolve } from "node:path";
+function getLocalVersion() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname3(__filename);
+  const candidates = [
+    resolve(__dirname, "..", "package.json"),
+    resolve(__dirname, "..", "..", "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const raw = readFileSync5(candidate, "utf-8");
+      const pkg = JSON.parse(raw);
+      return pkg.version;
+    } catch {
+      continue;
+    }
+  }
+  return "unknown";
+}
+function getVersion() {
+  return getLocalVersion();
+}
+
 // src/mcp/server.ts
 function createServer() {
   const server2 = new McpServer({
     name: "krx-cli",
-    version: "1.2.0"
+    version: getVersion()
   });
   const allTools = [
     ...createCategoryTools(),
     createSchemaTool(),
-    createRateLimitTool()
+    createRateLimitTool(),
+    createSearchTool(),
+    createMarketSummaryTool(),
+    createWatchlistTool()
   ];
   for (const tool of allTools) {
     server2.tool(tool.name, tool.description, tool.inputSchema, async (args) => {
       return tool.handler(args);
     });
   }
+  const allResources = [
+    createWatchlistResource(),
+    createRateLimitResource(),
+    createServiceStatusResource()
+  ];
+  for (const resource of allResources) {
+    server2.resource(resource.name, resource.uri, async (uri) => {
+      return resource.handler(uri);
+    });
+  }
   return server2;
 }