@md2do/cli 0.4.0 → 0.5.0

package/dist/cli.js

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_commander4 = require("commander");
-var import_fs = require("fs");
-var import_path = require("path");
+var import_commander5 = require("commander");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
 
 // src/commands/list.ts
 var import_commander = require("commander");
@@ -1202,21 +1202,481 @@ async function todoistSyncAction(options) {
   console.log("");
 }
 
+// src/commands/config.ts
+var import_commander4 = require("commander");
+var import_config3 = require("@md2do/config");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+var import_child_process = require("child_process");
+var import_js_yaml = __toESM(require("js-yaml"));
+function createConfigCommand() {
+  const command = new import_commander4.Command("config");
+  command.description("Manage md2do configuration");
+  command.addCommand(createConfigInitCommand());
+  command.addCommand(createConfigSetCommand());
+  command.addCommand(createConfigGetCommand());
+  command.addCommand(createConfigListCommand());
+  command.addCommand(createConfigEditCommand());
+  command.addCommand(createConfigValidateCommand());
+  return command;
+}
+function createConfigInitCommand() {
+  const command = new import_commander4.Command("init");
+  command.description("Initialize md2do configuration with interactive prompts").option("-g, --global", "Create global configuration in home directory").option(
+    "--format <type>",
+    "Config file format (json|yaml|js)",
+    "json"
+  ).option("--default-assignee <username>", "Default assignee username").option("--workday-start <time>", "Work day start time (HH:MM)").option("--workday-end <time>", "Work day end time (HH:MM)").option(
+    "--default-due-time <when>",
+    "Default due time (start|end)",
+    "end"
+  ).option(
+    "--output-format <type>",
+    "Output format (pretty|table|json)",
+    "pretty"
+  ).option("--no-colors", "Disable colored output").option(
+    "--warnings <level>",
+    "Warning level (recommended|strict|off)",
+    "recommended"
+  ).action(async (options) => {
+    try {
+      await configInitAction(options);
+    } catch (error) {
+      if (error instanceof Error && error.message === "canceled") {
+        const p = await import("@clack/prompts");
+        p.cancel("Configuration canceled");
+        process.exit(0);
+      }
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+async function configInitAction(options) {
+  const p = await import("@clack/prompts");
+  p.intro("Welcome to md2do configuration!");
+  const hasAnyOption = options.defaultAssignee !== void 0 || options.workdayStart !== void 0 || options.workdayEnd !== void 0 || options.defaultDueTime !== void 0 || options.outputFormat !== void 0 || options.colors !== void 0 || options.warnings !== void 0;
+  const interactive = !hasAnyOption;
+  const config = {};
+  if (interactive) {
+    const defaultAssignee = await p.text({
+      message: "Your username (for filtering tasks):",
+      placeholder: "Leave empty to skip",
+      validate: (value) => {
+        if (value && !/^[a-zA-Z0-9_-]+$/.test(value)) {
+          return "Username should only contain letters, numbers, dashes, and underscores";
+        }
+      }
+    });
+    const workdayStart = await p.text({
+      message: "Work day start time (HH:MM):",
+      initialValue: "08:00",
+      validate: (value) => {
+        if (typeof value === "string" && !/^\d{2}:\d{2}$/.test(value)) {
+          return "Time must be in HH:MM format";
+        }
+      }
+    });
+    const workdayEnd = await p.text({
+      message: "Work day end time (HH:MM):",
+      initialValue: "17:00",
+      validate: (value) => {
+        if (typeof value === "string" && !/^\d{2}:\d{2}$/.test(value)) {
+          return "Time must be in HH:MM format";
+        }
+      }
+    });
+    const defaultDueTime = await p.select({
+      message: "Default due time:",
+      options: [
+        { value: "end", label: "End of day" },
+        { value: "start", label: "Start of day" }
+      ],
+      initialValue: "end"
+    });
+    const outputFormat = await p.select({
+      message: "Output format:",
+      options: [
+        { value: "pretty", label: "Pretty (human-readable)" },
+        { value: "table", label: "Table (structured)" },
+        { value: "json", label: "JSON (machine-readable)" }
+      ],
+      initialValue: "pretty"
+    });
+    const colors = await p.confirm({
+      message: "Enable colored output?",
+      initialValue: true
+    });
+    const warnings = await p.select({
+      message: "Warning level:",
+      options: [
+        {
+          value: "recommended",
+          label: "Recommended (validates format, metadata optional)"
+        },
+        {
+          value: "strict",
+          label: "Strict (enforces complete metadata)"
+        },
+        { value: "off", label: "Off (no warnings)" }
+      ],
+      initialValue: "recommended"
+    });
+    if (defaultAssignee && typeof defaultAssignee === "string") {
+      config.defaultAssignee = defaultAssignee;
+    }
+    config.workday = {
+      startTime: typeof workdayStart === "string" ? workdayStart : "08:00",
+      endTime: typeof workdayEnd === "string" ? workdayEnd : "17:00",
+      defaultDueTime: typeof defaultDueTime === "string" ? defaultDueTime : "end"
+    };
+    config.output = {
+      format: typeof outputFormat === "string" ? outputFormat : "pretty",
+      colors: typeof colors === "boolean" ? colors : true,
+      paths: true
+    };
+    if (typeof warnings === "string" && warnings === "off") {
+      config.warnings = { enabled: false };
+    } else if (typeof warnings === "string" && warnings === "strict") {
+      config.warnings = {
+        enabled: true,
+        rules: {
+          "unsupported-bullet": "warn",
+          "malformed-checkbox": "warn",
+          "missing-space-after": "warn",
+          "missing-space-before": "warn",
+          "relative-date-no-context": "warn",
+          "missing-due-date": "warn",
+          "missing-completed-date": "warn",
+          "duplicate-todoist-id": "error",
+          "file-read-error": "error"
+        }
+      };
+    }
+  } else {
+    if (options.defaultAssignee) {
+      config.defaultAssignee = options.defaultAssignee;
+    }
+    config.workday = {
+      startTime: options.workdayStart || "08:00",
+      endTime: options.workdayEnd || "17:00",
+      defaultDueTime: options.defaultDueTime || "end"
+    };
+    config.output = {
+      format: options.outputFormat || "pretty",
+      colors: options.colors ?? true,
+      paths: true
+    };
+    if (options.warnings === "off") {
+      config.warnings = { enabled: false };
+    } else if (options.warnings === "strict") {
+      config.warnings = {
+        enabled: true,
+        rules: {
+          "unsupported-bullet": "warn",
+          "malformed-checkbox": "warn",
+          "missing-space-after": "warn",
+          "missing-space-before": "warn",
+          "relative-date-no-context": "warn",
+          "missing-due-date": "warn",
+          "missing-completed-date": "warn",
+          "duplicate-todoist-id": "error",
+          "file-read-error": "error"
+        }
+      };
+    }
+  }
+  try {
+    (0, import_config3.validateConfig)(config);
+  } catch (error) {
+    p.cancel(
+      `Invalid configuration: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+  const format = options.format || "json";
+  const configPath = getConfigPath(options.global || false, format);
+  if ((0, import_fs.existsSync)(configPath)) {
+    if (interactive) {
+      const overwrite = await p.confirm({
+        message: `Configuration file already exists at ${configPath}. Overwrite?`,
+        initialValue: false
+      });
+      if (!overwrite) {
+        p.cancel("Configuration canceled");
+        process.exit(0);
+      }
+    }
+  }
+  writeConfigFile(configPath, config, format);
+  p.outro(`\u2713 Configuration saved to ${configPath}`);
+}
+function createConfigSetCommand() {
+  const command = new import_commander4.Command("set");
+  command.description("Set a configuration value").argument("<key>", "Configuration key (e.g., workday.startTime)").argument("<value>", "Configuration value").option("-g, --global", "Set in global configuration").action((key, value, options) => {
+    try {
+      configSetAction(key, value, options);
+    } catch (error) {
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+function configSetAction(key, value, options) {
+  const isGlobal = options.global || false;
+  const configPath = findExistingConfigPath(isGlobal);
+  let config = {};
+  let format = "json";
+  if (configPath) {
+    format = getConfigFormat(configPath);
+    const content = (0, import_fs.readFileSync)(configPath, "utf-8");
+    config = parseConfigFile(content, format);
+  } else {
+    format = "json";
+  }
+  const parsedValue = parseValue(value);
+  setNestedValue(config, key, parsedValue);
+  try {
+    (0, import_config3.validateConfig)(config);
+  } catch (error) {
+    console.error(
+      `Invalid configuration: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+  const finalPath = configPath || getConfigPath(isGlobal, format);
+  writeConfigFile(finalPath, config, format);
+  console.log(`\u2713 Set ${key} = ${value} in ${finalPath}`);
+}
+function createConfigGetCommand() {
+  const command = new import_commander4.Command("get");
+  command.description("Get a configuration value").argument("<key>", "Configuration key (e.g., workday.startTime)").option("-g, --global", "Get from global configuration only").action(async (key, options) => {
+    try {
+      await configGetAction(key, options);
+    } catch (error) {
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+async function configGetAction(key, options) {
+  const config = options.global ? await (0, import_config3.loadConfig)({ loadGlobal: true, loadEnv: false, cwd: (0, import_os.homedir)() }) : await (0, import_config3.loadConfig)();
+  const value = getNestedValue(config, key);
+  if (value === void 0) {
+    console.log("(not set)");
+  } else if (typeof value === "object") {
+    console.log(JSON.stringify(value, null, 2));
+  } else {
+    console.log(value);
+  }
+}
+function createConfigListCommand() {
+  const command = new import_commander4.Command("list");
+  command.description("Show all configuration values").option("--show-origin", "Show where each value comes from").action(async (options) => {
+    try {
+      await configListAction(options);
+    } catch (error) {
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+async function configListAction(options) {
+  const config = await (0, import_config3.loadConfig)();
+  console.log("");
+  console.log("Current configuration:");
+  console.log("");
+  console.log(JSON.stringify(config, null, 2));
+  console.log("");
+  if (options.showOrigin) {
+    console.log("Configuration sources:");
+    console.log("  1. Default values (built-in)");
+    console.log(`  2. Global config (${getConfigPath(true, "json")})`);
+    console.log(`  3. Project config (${getConfigPath(false, "json")})`);
+    console.log("  4. Environment variables");
+    console.log("");
+  }
+}
+function createConfigEditCommand() {
+  const command = new import_commander4.Command("edit");
+  command.description("Open configuration file in your default editor").option("-g, --global", "Edit global configuration").action((options) => {
+    try {
+      configEditAction(options);
+    } catch (error) {
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+function configEditAction(options) {
+  const isGlobal = options.global || false;
+  let configPath = findExistingConfigPath(isGlobal);
+  if (!configPath) {
+    configPath = getConfigPath(isGlobal, "json");
+    writeConfigFile(configPath, {}, "json");
+    console.log(`Created new configuration file: ${configPath}`);
+  }
+  const editor = process.env.VISUAL || process.env.EDITOR || (process.platform === "win32" ? "notepad" : "vi");
+  console.log(`Opening ${configPath} in ${editor}...`);
+  try {
+    (0, import_child_process.execSync)(`${editor} '${configPath}'`, { stdio: "inherit" });
+  } catch (error) {
+    console.error("Failed to open editor");
+    console.error(`You can manually edit the file at: ${configPath}`);
+    process.exit(1);
+  }
+}
+function createConfigValidateCommand() {
+  const command = new import_commander4.Command("validate");
+  command.description("Validate current configuration").action(async () => {
+    try {
+      await configValidateAction();
+    } catch (error) {
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+async function configValidateAction() {
+  try {
+    const config = await (0, import_config3.loadConfig)();
+    (0, import_config3.validateConfig)(config);
+    console.log("\u2713 Configuration is valid");
+  } catch (error) {
+    console.error(
+      `Invalid configuration: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+}
+function getConfigPath(isGlobal, format) {
+  const base = isGlobal ? (0, import_os.homedir)() : process.cwd();
+  const fileName = format === "json" ? ".md2do.json" : format === "yaml" ? ".md2do.yaml" : ".md2do.js";
+  return (0, import_path.join)(base, fileName);
+}
+function findExistingConfigPath(isGlobal) {
+  const base = isGlobal ? (0, import_os.homedir)() : process.cwd();
+  const possibleFiles = [
+    ".md2do.json",
+    ".md2do.yaml",
+    ".md2do.yml",
+    ".md2do.js",
+    ".md2do.cjs",
+    "md2do.config.js",
+    "md2do.config.cjs"
+  ];
+  for (const file of possibleFiles) {
+    const path = (0, import_path.join)(base, file);
+    if ((0, import_fs.existsSync)(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+function getConfigFormat(path) {
+  if (path.endsWith(".json")) return "json";
+  if (path.endsWith(".yaml") || path.endsWith(".yml")) return "yaml";
+  return "js";
+}
+function parseConfigFile(content, format) {
+  if (format === "json") {
+    return JSON.parse(content);
+  } else if (format === "yaml") {
+    const loaded = import_js_yaml.default.load(content);
+    return loaded || {};
+  } else {
+    return JSON.parse(content);
+  }
+}
+function writeConfigFile(path, config, format) {
+  let content;
+  if (format === "json") {
+    content = JSON.stringify(config, null, 2) + "\n";
+  } else if (format === "yaml") {
+    content = import_js_yaml.default.dump(config);
+  } else {
+    content = `module.exports = ${JSON.stringify(config, null, 2)};
+`;
+  }
+  (0, import_fs.writeFileSync)(path, content, "utf-8");
+}
+function parseValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const num = Number(value);
+  if (!isNaN(num)) return num;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  if (!lastKey) return;
+  let current = obj;
+  for (const key of keys) {
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[lastKey] = value;
+}
+
 // src/cli.ts
 var getVersion = () => {
   try {
-    const packagePath = (0, import_path.join)(__dirname, "../package.json");
-    const packageJson = JSON.parse((0, import_fs.readFileSync)(packagePath, "utf-8"));
+    const packagePath = (0, import_path2.join)(__dirname, "../package.json");
+    const packageJson = JSON.parse((0, import_fs2.readFileSync)(packagePath, "utf-8"));
     return packageJson.version;
   } catch {
     return "0.0.0";
   }
 };
-var program = new import_commander4.Command();
+var program = new import_commander5.Command();
 program.name("md2do").description("Scan and manage TODOs in markdown files").version(getVersion());
 program.addCommand(createListCommand());
 program.addCommand(createStatsCommand());
 program.addCommand(createTodoistCommand());
+program.addCommand(createConfigCommand());
 if (process.argv.length === 2) {
   program.help();
 }

package/dist/index.d.ts

@@ -9,4 +9,9 @@ declare function createStatsCommand(): Command;
  */
 declare function createTodoistCommand(): Command;
 
-export { createListCommand, createStatsCommand, createTodoistCommand };
+/**
+ * Create the config command group
+ */
+declare function createConfigCommand(): Command;
+
+export { createConfigCommand, createListCommand, createStatsCommand, createTodoistCommand };