@dexto/tools-plan 1.6.0 → 1.6.1

package/dist/plan-service.cjs

@@ -0,0 +1,247 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_service_exports = {};
+__export(plan_service_exports, {
+  PlanService: () => PlanService
+});
+module.exports = __toCommonJS(plan_service_exports);
+var fs = __toESM(require("node:fs/promises"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_node_fs = require("node:fs");
+var import_types = require("./types.js");
+var import_errors = require("./errors.js");
+const PLAN_FILENAME = "plan.md";
+const META_FILENAME = "plan-meta.json";
+class PlanService {
+  basePath;
+  logger;
+  constructor(options, logger) {
+    this.basePath = options.basePath;
+    this.logger = logger;
+  }
+  /**
+   * Resolves and validates a session directory path.
+   * Prevents path traversal attacks by ensuring the resolved path stays within basePath.
+   */
+  resolveSessionDir(sessionId) {
+    const base = path.resolve(this.basePath);
+    const resolved = path.resolve(base, sessionId);
+    const rel = path.relative(base, resolved);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+      throw import_errors.PlanError.invalidSessionId(sessionId);
+    }
+    return resolved;
+  }
+  /**
+   * Gets the directory path for a session's plan
+   */
+  getPlanDir(sessionId) {
+    return this.resolveSessionDir(sessionId);
+  }
+  /**
+   * Gets the path to the plan content file.
+   * Public accessor for tools that need to display the path.
+   */
+  getPlanPath(sessionId) {
+    return path.join(this.getPlanDir(sessionId), PLAN_FILENAME);
+  }
+  /**
+   * Gets the path to the plan metadata file
+   */
+  getMetaPath(sessionId) {
+    return path.join(this.getPlanDir(sessionId), META_FILENAME);
+  }
+  /**
+   * Checks if a plan exists for the given session
+   */
+  async exists(sessionId) {
+    const planPath = this.getPlanPath(sessionId);
+    return (0, import_node_fs.existsSync)(planPath);
+  }
+  /**
+   * Creates a new plan for the session
+   *
+   * @throws PlanError.planAlreadyExists if plan already exists
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async create(sessionId, content, options) {
+    if (await this.exists(sessionId)) {
+      throw import_errors.PlanError.planAlreadyExists(sessionId);
+    }
+    const planDir = this.getPlanDir(sessionId);
+    const now = Date.now();
+    const meta = {
+      sessionId,
+      status: "draft",
+      title: options?.title,
+      createdAt: now,
+      updatedAt: now
+    };
+    try {
+      await fs.mkdir(planDir, { recursive: true });
+      await Promise.all([
+        fs.writeFile(this.getPlanPath(sessionId), content, "utf-8"),
+        fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(meta, null, 2), "utf-8")
+      ]);
+      this.logger.debug(`Created plan for session ${sessionId}`);
+      return { content, meta };
+    } catch (error) {
+      throw import_errors.PlanError.storageError("create", sessionId, error);
+    }
+  }
+  /**
+   * Reads the plan for the given session
+   *
+   * @returns The plan or null if not found
+   */
+  async read(sessionId) {
+    if (!await this.exists(sessionId)) {
+      return null;
+    }
+    try {
+      const [content, metaContent] = await Promise.all([
+        fs.readFile(this.getPlanPath(sessionId), "utf-8"),
+        fs.readFile(this.getMetaPath(sessionId), "utf-8")
+      ]);
+      const metaParsed = JSON.parse(metaContent);
+      const metaResult = import_types.PlanMetaSchema.safeParse(metaParsed);
+      if (!metaResult.success) {
+        this.logger.warn(`Invalid plan metadata for session ${sessionId}, using defaults`);
+        return {
+          content,
+          meta: {
+            sessionId,
+            status: "draft",
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+          }
+        };
+      }
+      return { content, meta: metaResult.data };
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        return null;
+      }
+      if (error instanceof SyntaxError) {
+        this.logger.error(`Failed to read plan for session ${sessionId}: ${error.message}`);
+        return null;
+      }
+      this.logger.error(
+        `Failed to read plan for session ${sessionId}: ${err.message ?? String(err)}`
+      );
+      throw import_errors.PlanError.storageError("read", sessionId, err);
+    }
+  }
+  /**
+   * Updates the plan content for the given session
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async update(sessionId, content) {
+    const existing = await this.read(sessionId);
+    if (!existing) {
+      throw import_errors.PlanError.planNotFound(sessionId);
+    }
+    const oldContent = existing.content;
+    const now = Date.now();
+    const updatedMeta = {
+      ...existing.meta,
+      updatedAt: now
+    };
+    try {
+      await Promise.all([
+        fs.writeFile(this.getPlanPath(sessionId), content, "utf-8"),
+        fs.writeFile(
+          this.getMetaPath(sessionId),
+          JSON.stringify(updatedMeta, null, 2),
+          "utf-8"
+        )
+      ]);
+      this.logger.debug(`Updated plan for session ${sessionId}`);
+      return {
+        oldContent,
+        newContent: content,
+        meta: updatedMeta
+      };
+    } catch (error) {
+      throw import_errors.PlanError.storageError("update", sessionId, error);
+    }
+  }
+  /**
+   * Updates the plan metadata (status, title)
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async updateMeta(sessionId, updates) {
+    const existing = await this.read(sessionId);
+    if (!existing) {
+      throw import_errors.PlanError.planNotFound(sessionId);
+    }
+    const updatedMeta = {
+      ...existing.meta,
+      ...updates,
+      updatedAt: Date.now()
+    };
+    try {
+      await fs.writeFile(
+        this.getMetaPath(sessionId),
+        JSON.stringify(updatedMeta, null, 2),
+        "utf-8"
+      );
+      this.logger.debug(`Updated plan metadata for session ${sessionId}`);
+      return updatedMeta;
+    } catch (error) {
+      throw import_errors.PlanError.storageError("update metadata", sessionId, error);
+    }
+  }
+  /**
+   * Deletes the plan for the given session
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async delete(sessionId) {
+    if (!await this.exists(sessionId)) {
+      throw import_errors.PlanError.planNotFound(sessionId);
+    }
+    try {
+      await fs.rm(this.getPlanDir(sessionId), { recursive: true, force: true });
+      this.logger.debug(`Deleted plan for session ${sessionId}`);
+    } catch (error) {
+      throw import_errors.PlanError.storageError("delete", sessionId, error);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlanService
+});

package/dist/plan-service.js

@@ -1,227 +1,213 @@
-/**
- * Plan Service
- *
- * Handles storage and retrieval of implementation plans.
- * Plans are stored in .dexto/plans/{sessionId}/ with:
- * - plan.md: The plan content
- * - plan-meta.json: Metadata (status, checkpoints, timestamps)
- */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { existsSync } from 'node:fs';
-import { PlanMetaSchema } from './types.js';
-import { PlanError } from './errors.js';
-const PLAN_FILENAME = 'plan.md';
-const META_FILENAME = 'plan-meta.json';
-/**
- * Service for managing implementation plans.
- */
-export class PlanService {
-    basePath;
-    logger;
-    constructor(options, logger) {
-        this.basePath = options.basePath;
-        this.logger = logger;
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { existsSync } from "node:fs";
+import { PlanMetaSchema } from "./types.js";
+import { PlanError } from "./errors.js";
+const PLAN_FILENAME = "plan.md";
+const META_FILENAME = "plan-meta.json";
+class PlanService {
+  basePath;
+  logger;
+  constructor(options, logger) {
+    this.basePath = options.basePath;
+    this.logger = logger;
+  }
+  /**
+   * Resolves and validates a session directory path.
+   * Prevents path traversal attacks by ensuring the resolved path stays within basePath.
+   */
+  resolveSessionDir(sessionId) {
+    const base = path.resolve(this.basePath);
+    const resolved = path.resolve(base, sessionId);
+    const rel = path.relative(base, resolved);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+      throw PlanError.invalidSessionId(sessionId);
     }
-    /**
-     * Resolves and validates a session directory path.
-     * Prevents path traversal attacks by ensuring the resolved path stays within basePath.
-     */
-    resolveSessionDir(sessionId) {
-        const base = path.resolve(this.basePath);
-        const resolved = path.resolve(base, sessionId);
-        const rel = path.relative(base, resolved);
-        // Check for path traversal (upward traversal)
-        if (rel.startsWith('..') || path.isAbsolute(rel)) {
-            throw PlanError.invalidSessionId(sessionId);
-        }
-        return resolved;
+    return resolved;
+  }
+  /**
+   * Gets the directory path for a session's plan
+   */
+  getPlanDir(sessionId) {
+    return this.resolveSessionDir(sessionId);
+  }
+  /**
+   * Gets the path to the plan content file.
+   * Public accessor for tools that need to display the path.
+   */
+  getPlanPath(sessionId) {
+    return path.join(this.getPlanDir(sessionId), PLAN_FILENAME);
+  }
+  /**
+   * Gets the path to the plan metadata file
+   */
+  getMetaPath(sessionId) {
+    return path.join(this.getPlanDir(sessionId), META_FILENAME);
+  }
+  /**
+   * Checks if a plan exists for the given session
+   */
+  async exists(sessionId) {
+    const planPath = this.getPlanPath(sessionId);
+    return existsSync(planPath);
+  }
+  /**
+   * Creates a new plan for the session
+   *
+   * @throws PlanError.planAlreadyExists if plan already exists
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async create(sessionId, content, options) {
+    if (await this.exists(sessionId)) {
+      throw PlanError.planAlreadyExists(sessionId);
     }
-    /**
-     * Gets the directory path for a session's plan
-     */
-    getPlanDir(sessionId) {
-        return this.resolveSessionDir(sessionId);
+    const planDir = this.getPlanDir(sessionId);
+    const now = Date.now();
+    const meta = {
+      sessionId,
+      status: "draft",
+      title: options?.title,
+      createdAt: now,
+      updatedAt: now
+    };
+    try {
+      await fs.mkdir(planDir, { recursive: true });
+      await Promise.all([
+        fs.writeFile(this.getPlanPath(sessionId), content, "utf-8"),
+        fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(meta, null, 2), "utf-8")
+      ]);
+      this.logger.debug(`Created plan for session ${sessionId}`);
+      return { content, meta };
+    } catch (error) {
+      throw PlanError.storageError("create", sessionId, error);
     }
-    /**
-     * Gets the path to the plan content file.
-     * Public accessor for tools that need to display the path.
-     */
-    getPlanPath(sessionId) {
-        return path.join(this.getPlanDir(sessionId), PLAN_FILENAME);
+  }
+  /**
+   * Reads the plan for the given session
+   *
+   * @returns The plan or null if not found
+   */
+  async read(sessionId) {
+    if (!await this.exists(sessionId)) {
+      return null;
     }
-    /**
-     * Gets the path to the plan metadata file
-     */
-    getMetaPath(sessionId) {
-        return path.join(this.getPlanDir(sessionId), META_FILENAME);
-    }
-    /**
-     * Checks if a plan exists for the given session
-     */
-    async exists(sessionId) {
-        const planPath = this.getPlanPath(sessionId);
-        return existsSync(planPath);
-    }
-    /**
-     * Creates a new plan for the session
-     *
-     * @throws PlanError.planAlreadyExists if plan already exists
-     * @throws PlanError.storageError on filesystem errors
-     */
-    async create(sessionId, content, options) {
-        // Check if plan already exists
-        if (await this.exists(sessionId)) {
-            throw PlanError.planAlreadyExists(sessionId);
-        }
-        const planDir = this.getPlanDir(sessionId);
-        const now = Date.now();
-        // Create metadata
-        const meta = {
+    try {
+      const [content, metaContent] = await Promise.all([
+        fs.readFile(this.getPlanPath(sessionId), "utf-8"),
+        fs.readFile(this.getMetaPath(sessionId), "utf-8")
+      ]);
+      const metaParsed = JSON.parse(metaContent);
+      const metaResult = PlanMetaSchema.safeParse(metaParsed);
+      if (!metaResult.success) {
+        this.logger.warn(`Invalid plan metadata for session ${sessionId}, using defaults`);
+        return {
+          content,
+          meta: {
             sessionId,
-            status: 'draft',
-            title: options?.title,
-            createdAt: now,
-            updatedAt: now,
+            status: "draft",
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+          }
         };
-        try {
-            // Ensure directory exists
-            await fs.mkdir(planDir, { recursive: true });
-            // Write plan content and metadata
-            await Promise.all([
-                fs.writeFile(this.getPlanPath(sessionId), content, 'utf-8'),
-                fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(meta, null, 2), 'utf-8'),
-            ]);
-            this.logger.debug(`Created plan for session ${sessionId}`);
-            return { content, meta };
-        }
-        catch (error) {
-            throw PlanError.storageError('create', sessionId, error);
-        }
+      }
+      return { content, meta: metaResult.data };
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        return null;
+      }
+      if (error instanceof SyntaxError) {
+        this.logger.error(`Failed to read plan for session ${sessionId}: ${error.message}`);
+        return null;
+      }
+      this.logger.error(
+        `Failed to read plan for session ${sessionId}: ${err.message ?? String(err)}`
+      );
+      throw PlanError.storageError("read", sessionId, err);
     }
-    /**
-     * Reads the plan for the given session
-     *
-     * @returns The plan or null if not found
-     */
-    async read(sessionId) {
-        if (!(await this.exists(sessionId))) {
-            return null;
-        }
-        try {
-            const [content, metaContent] = await Promise.all([
-                fs.readFile(this.getPlanPath(sessionId), 'utf-8'),
-                fs.readFile(this.getMetaPath(sessionId), 'utf-8'),
-            ]);
-            const metaParsed = JSON.parse(metaContent);
-            const metaResult = PlanMetaSchema.safeParse(metaParsed);
-            if (!metaResult.success) {
-                this.logger.warn(`Invalid plan metadata for session ${sessionId}, using defaults`);
-                // Return with minimal metadata if parsing fails
-                return {
-                    content,
-                    meta: {
-                        sessionId,
-                        status: 'draft',
-                        createdAt: Date.now(),
-                        updatedAt: Date.now(),
-                    },
-                };
-            }
-            return { content, meta: metaResult.data };
-        }
-        catch (error) {
-            const err = error;
-            // ENOENT means file doesn't exist - return null (expected case)
-            if (err.code === 'ENOENT') {
-                return null;
-            }
-            // JSON parse errors (SyntaxError) mean corrupted data - treat as not found
-            // but log for debugging
-            if (error instanceof SyntaxError) {
-                this.logger.error(`Failed to read plan for session ${sessionId}: ${error.message}`);
-                return null;
-            }
-            // For real I/O errors (permission denied, disk issues), throw to surface the issue
-            this.logger.error(`Failed to read plan for session ${sessionId}: ${err.message ?? String(err)}`);
-            throw PlanError.storageError('read', sessionId, err);
-        }
+  }
+  /**
+   * Updates the plan content for the given session
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async update(sessionId, content) {
+    const existing = await this.read(sessionId);
+    if (!existing) {
+      throw PlanError.planNotFound(sessionId);
     }
-    /**
-     * Updates the plan content for the given session
-     *
-     * @throws PlanError.planNotFound if plan doesn't exist
-     * @throws PlanError.storageError on filesystem errors
-     */
-    async update(sessionId, content) {
-        const existing = await this.read(sessionId);
-        if (!existing) {
-            throw PlanError.planNotFound(sessionId);
-        }
-        const oldContent = existing.content;
-        const now = Date.now();
-        // Update metadata
-        const updatedMeta = {
-            ...existing.meta,
-            updatedAt: now,
-        };
-        try {
-            await Promise.all([
-                fs.writeFile(this.getPlanPath(sessionId), content, 'utf-8'),
-                fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(updatedMeta, null, 2), 'utf-8'),
-            ]);
-            this.logger.debug(`Updated plan for session ${sessionId}`);
-            return {
-                oldContent,
-                newContent: content,
-                meta: updatedMeta,
-            };
-        }
-        catch (error) {
-            throw PlanError.storageError('update', sessionId, error);
-        }
+    const oldContent = existing.content;
+    const now = Date.now();
+    const updatedMeta = {
+      ...existing.meta,
+      updatedAt: now
+    };
+    try {
+      await Promise.all([
+        fs.writeFile(this.getPlanPath(sessionId), content, "utf-8"),
+        fs.writeFile(
+          this.getMetaPath(sessionId),
+          JSON.stringify(updatedMeta, null, 2),
+          "utf-8"
+        )
+      ]);
+      this.logger.debug(`Updated plan for session ${sessionId}`);
+      return {
+        oldContent,
+        newContent: content,
+        meta: updatedMeta
+      };
+    } catch (error) {
+      throw PlanError.storageError("update", sessionId, error);
     }
-    /**
-     * Updates the plan metadata (status, title)
-     *
-     * @throws PlanError.planNotFound if plan doesn't exist
-     * @throws PlanError.storageError on filesystem errors
-     */
-    async updateMeta(sessionId, updates) {
-        const existing = await this.read(sessionId);
-        if (!existing) {
-            throw PlanError.planNotFound(sessionId);
-        }
-        const updatedMeta = {
-            ...existing.meta,
-            ...updates,
-            updatedAt: Date.now(),
-        };
-        try {
-            await fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(updatedMeta, null, 2), 'utf-8');
-            this.logger.debug(`Updated plan metadata for session ${sessionId}`);
-            return updatedMeta;
-        }
-        catch (error) {
-            throw PlanError.storageError('update metadata', sessionId, error);
-        }
+  }
+  /**
+   * Updates the plan metadata (status, title)
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async updateMeta(sessionId, updates) {
+    const existing = await this.read(sessionId);
+    if (!existing) {
+      throw PlanError.planNotFound(sessionId);
+    }
+    const updatedMeta = {
+      ...existing.meta,
+      ...updates,
+      updatedAt: Date.now()
+    };
+    try {
+      await fs.writeFile(
+        this.getMetaPath(sessionId),
+        JSON.stringify(updatedMeta, null, 2),
+        "utf-8"
+      );
+      this.logger.debug(`Updated plan metadata for session ${sessionId}`);
+      return updatedMeta;
+    } catch (error) {
+      throw PlanError.storageError("update metadata", sessionId, error);
+    }
+  }
+  /**
+   * Deletes the plan for the given session
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async delete(sessionId) {
+    if (!await this.exists(sessionId)) {
+      throw PlanError.planNotFound(sessionId);
     }
-    /**
-     * Deletes the plan for the given session
-     *
-     * @throws PlanError.planNotFound if plan doesn't exist
-     * @throws PlanError.storageError on filesystem errors
-     */
-    async delete(sessionId) {
-        if (!(await this.exists(sessionId))) {
-            throw PlanError.planNotFound(sessionId);
-        }
-        try {
-            await fs.rm(this.getPlanDir(sessionId), { recursive: true, force: true });
-            this.logger.debug(`Deleted plan for session ${sessionId}`);
-        }
-        catch (error) {
-            throw PlanError.storageError('delete', sessionId, error);
-        }
+    try {
+      await fs.rm(this.getPlanDir(sessionId), { recursive: true, force: true });
+      this.logger.debug(`Deleted plan for session ${sessionId}`);
+    } catch (error) {
+      throw PlanError.storageError("delete", sessionId, error);
     }
+  }
 }
+export {
+  PlanService
+};