@brainervirus/workit-core 0.10.0 → 1.0.0

package/src/core/config-conversion.ts

@@ -0,0 +1,183 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { isConfigObject, mergePreset, type BranchPreset, type ToolkitConfig } from "./config";
+
+export type ConversionInput = {
+  configDir: string;
+};
+
+export type ConversionMapping = {
+  key: string;
+  from: unknown;
+  to: unknown;
+  note?: string;
+};
+
+export type ConversionUnresolved = {
+  key: string;
+  reason: string;
+};
+
+export type ConversionPreview = {
+  mappings: ConversionMapping[];
+  preserved: string[];
+  unresolved: ConversionUnresolved[];
+};
+
+const REDACT_KEYS = /token|secret|password|credential/i;
+
+const readJsonObject = (file: string): Record<string, unknown> | null => {
+  if (!existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return isConfigObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+
+const redactValue = (key: string, value: unknown): unknown => {
+  if (REDACT_KEYS.test(key)) return "[redacted]";
+  if (typeof value === "string" && value.length > 8 && !value.includes(" ")) return "[redacted]";
+  return value;
+};
+
+export const redactConversionPreview = (preview: ConversionPreview): ConversionPreview => ({
+  mappings: preview.mappings.map((m) => ({
+    ...m,
+    from: redactValue(m.key, m.from),
+    to: redactValue(m.key, m.to),
+  })),
+  preserved: preview.preserved,
+  unresolved: preview.unresolved,
+});
+
+export function previewConversion(input: ConversionInput): ConversionPreview {
+  const configFile = path.join(input.configDir, "config.json");
+  const config = readJsonObject(configFile);
+  const mappings: ConversionMapping[] = [];
+  const unresolved: ConversionUnresolved[] = [];
+  const preserved: string[] = [];
+
+  if (config) {
+    if (config.locale !== undefined) {
+      mappings.push({ key: "locale", from: config.locale, to: config.locale });
+    }
+    if (config.timezone !== undefined) {
+      mappings.push({ key: "timezone", from: config.timezone, to: config.timezone });
+    }
+    if (config.branchPolicy !== undefined && isConfigObject(config.branchPolicy)) {
+      const bp = config.branchPolicy as ToolkitConfig["branchPolicy"] & {
+        allowed?: string[];
+        protected?: string[];
+      };
+      const preset = (bp.preset ?? "gitflow") as BranchPreset;
+      const merged = mergePreset(
+        preset,
+        {
+          allowed: Array.isArray(bp.allowed) ? bp.allowed : undefined,
+          protectedNames: Array.isArray(bp.protected) ? bp.protected : undefined,
+        },
+        { branchPolicy: bp },
+      );
+      mappings.push({
+        key: "branchPolicy",
+        from: config.branchPolicy,
+        to: merged,
+        note: "preset-derived allowed/protected reset through mergePreset",
+      });
+      if (preset === "custom" && Array.isArray(bp.allowed)) {
+        if (bp.allowed.includes("*")) {
+          unresolved.push({
+            key: "branchPolicy.allowed",
+            reason: 'unsupported permissive value "*" requires an explicit v1 choice',
+          });
+        }
+      }
+    }
+    if (config.workflowMode !== undefined) {
+      unresolved.push({
+        key: "legacyWorkflowMode",
+        reason: "0.x workflow mode has no automatic v1 equivalent; choose how to continue",
+      });
+    }
+  }
+
+  for (const name of ["youtrack.json", "vcs.json", "workspaces.json"]) {
+    const file = path.join(input.configDir, name);
+    if (!existsSync(file)) continue;
+    const parsed = readJsonObject(file);
+    if (parsed)
+      mappings.push({ key: name, from: parsed, to: parsed, note: "carry forward unchanged" });
+  }
+
+  for (const token of ["youtrack.token", "gitlab.token", "github.token"]) {
+    const file = path.join(input.configDir, token);
+    if (existsSync(file)) preserved.push(file);
+  }
+
+  return { mappings, preserved, unresolved };
+}
+
+export const conversionDigest = (preview: ConversionPreview): string =>
+  createHash("sha256")
+    .update(JSON.stringify(redactConversionPreview(preview)))
+    .digest("hex");
+
+export type ConversionApplyResult = {
+  configPath: string;
+  choicesPath: string;
+};
+
+/** Apply approved conversion mappings and record explicit resolution choices. */
+export function applyConversionConfig(
+  configDir: string,
+  preview: ConversionPreview,
+  resolutions: Record<string, string>,
+): ConversionApplyResult {
+  const configFile = path.join(configDir, "config.json");
+  const raw = readJsonObject(configFile) ?? {};
+  const next: Record<string, unknown> = { ...raw };
+
+  for (const mapping of preview.mappings) {
+    if (mapping.key === "locale" || mapping.key === "timezone") {
+      next[mapping.key] = mapping.to;
+    }
+    if (mapping.key === "branchPolicy" && !resolutions["branchPolicy.allowed"]) {
+      next.branchPolicy = mapping.to;
+    }
+  }
+
+  if (resolutions["branchPolicy.allowed"]) {
+    const bp = isConfigObject(next.branchPolicy)
+      ? (next.branchPolicy as ToolkitConfig["branchPolicy"])
+      : { preset: "custom" as BranchPreset, allowed: [], protected: [] };
+    const preset = bp.preset ?? "custom";
+    next.branchPolicy = mergePreset(
+      preset,
+      {
+        allowed: resolutions["branchPolicy.allowed"]
+          .split(",")
+          .map((s) => s.trim())
+          .filter(Boolean),
+      },
+      { branchPolicy: bp },
+    );
+  }
+
+  if (resolutions["legacyWorkflowMode"]) {
+    delete next.workflowMode;
+  }
+
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(configFile, JSON.stringify(next, null, 2) + "\n");
+
+  const choicesPath = path.join(configDir, "cutover-choices.json");
+  writeFileSync(
+    choicesPath,
+    JSON.stringify({ resolutions, applied_at: new Date().toISOString() }, null, 2) + "\n",
+  );
+
+  return { configPath: configFile, choicesPath };
+}

package/src/core/config.ts

@@ -11,6 +11,7 @@ import os from "node:os";
 import path from "node:path";
 import type { Logger } from "./logger";
 import { EVENT, errorDetail } from "./boundary";
+import type { CommitFlavorPreset } from "./commit-flavors";
 
 // Optional diagnostic seam: adapters install their host logger so config
 // migration and provenance events land in the same sanitized log stream.
@@ -27,6 +28,7 @@ export type ToolkitConfig = {
   localeOptions: string[];
   timezone: string;
   branchPolicy: { preset: BranchPreset; allowed: string[]; protected: string[] };
+  commitPolicy: { preset: CommitFlavorPreset; pattern?: string };
 };
 
 export const PRESETS: Record<BranchPreset, { allowed: string[]; protected: string[] }> = {
@@ -135,6 +137,7 @@ const DEFAULTS: ToolkitConfig = {
     allowed: [...PRESETS.gitflow.allowed],
     protected: [...PRESETS.gitflow.protected],
   },
+  commitPolicy: { preset: "conventional" },
 };
 
 const readSafe = (p: string): string | null => {
@@ -183,6 +186,11 @@ const parseConfigResult = (raw: string | null, file: string): ReaderResult<Toolk
       ? input.branchPolicy?.preset
       : "gitflow"
   ) as BranchPreset;
+  const commitPreset = (
+    COMMIT_PRESETS.includes(String(input.commitPolicy?.preset ?? ""))
+      ? input.commitPolicy?.preset
+      : "conventional"
+  ) as CommitFlavorPreset;
   return {
     status: "valid",
     path: file,
@@ -206,6 +214,12 @@ const parseConfigResult = (raw: string | null, file: string): ReaderResult<Toolk
         },
         DEFAULTS,
       ),
+      commitPolicy: {
+        preset: commitPreset,
+        ...(typeof input.commitPolicy?.pattern === "string"
+          ? { pattern: input.commitPolicy.pattern }
+          : {}),
+      },
     },
   };
 };
@@ -236,6 +250,7 @@ export type ConfigInput = {
   preset?: BranchPreset;
   allowed?: string[];
   protectedNames?: string[];
+  commitPolicy?: ToolkitConfig["commitPolicy"];
 };
 
 // RL-02: the single authoritative ToolkitConfig merge. CLI, OpenCode, and Cursor
@@ -246,6 +261,7 @@ export const mergeConfigValues = (input: ConfigInput, current: ToolkitConfig): T
   localeOptions: input.localeOptions ?? current.localeOptions,
   timezone: input.timezone ?? current.timezone,
   branchPolicy: mergePreset(input.preset ?? current.branchPolicy.preset, input, current),
+  commitPolicy: input.commitPolicy ?? current.commitPolicy,
 });
 
 export const writeConfig = (config: ToolkitConfig): void => {
@@ -315,3 +331,29 @@ export const resolveBranchPolicy = (
       preset === "github-flow" ? "main" : preset === "trunk-based" ? "master" : "develop",
   };
 };
+
+const COMMIT_PRESETS: readonly string[] = [
+  "conventional",
+  "gitmoji",
+  "ticket-prefix",
+  "freeform",
+  "custom",
+  "auto",
+];
+
+/** Workspace commitPolicy override wins, else global — mirrors
+ * resolveBranchPolicy's workspace > global order, including the invalid-preset
+ * fallback instead of a crash. */
+export const resolveCommitPolicy = (
+  config: ToolkitConfig,
+  workspace?: { commitPolicy?: Record<string, any> } | null,
+): { preset: CommitFlavorPreset; pattern?: string } => {
+  const wp = (workspace?.commitPolicy ?? {}) as Record<string, any>;
+  if (COMMIT_PRESETS.includes(String(wp.preset ?? ""))) {
+    return {
+      preset: wp.preset as CommitFlavorPreset,
+      ...(typeof wp.pattern === "string" ? { pattern: wp.pattern } : {}),
+    };
+  }
+  return config.commitPolicy ?? ({ preset: "conventional" } as ToolkitConfig["commitPolicy"]);
+};