@duckmind/dm-windows-x64 0.63.4 → 0.63.6

package/extensions/dm-skills-manager/extensions/skills-manager/dm-ai-compat.js

@@ -0,0 +1,15 @@
+import * as piAi from "@duckmind/dm-ai";
+const dynamicImport = (specifier) => import(specifier);
+export async function completeSimple(model, context, options, deps = {}) {
+  const rootCompleteSimple = (deps.root ?? piAi).completeSimple;
+  if (typeof rootCompleteSimple === "function")
+    return await rootCompleteSimple(model, context, options);
+  const compat = deps.loadCompat ? await deps.loadCompat() : await dynamicImport("@duckmind/dm-ai/compat");
+  return await compat.completeSimple(model, context, options);
+}
+export async function retrySkillGenerationCompat(produce, signal, onRetryScheduled, deps = {}) {
+  const candidate = (deps.root ?? piAi).retryAssistantCall;
+  if (typeof candidate !== "function")
+    return produce();
+  return candidate(produce, { enabled: true, maxRetries: 3, baseDelayMs: 2000 }, signal, { onRetryScheduled });
+}

package/extensions/dm-skills-manager/extensions/skills-manager/format.js

@@ -0,0 +1,125 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir, parseFrontmatter, stripFrontmatter } from "@duckmind/dm-coding-agent";
+import { findProjectDmDir } from "./paths.js";
+export function normalizeSkillName(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9-\s]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+export function getTargetDir(ctx, location, skillName) {
+  return location === "global" ? join(getAgentDir(), "skills", skillName) : join(findProjectDmDir(ctx.cwd), "skills", skillName);
+}
+function formatScalar(value) {
+  if (typeof value === "string") {
+    if (value.length === 0)
+      return '""';
+    if (/^[A-Za-z0-9_./@,+()[\]\- ]+$/.test(value) && !value.includes(": ") && !/^\s|\s$/.test(value))
+      return value;
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null)
+    return "null";
+  return JSON.stringify(value);
+}
+export function formatYamlValue(key, value, indent = "") {
+  if (typeof value === "string" && value.includes(`
+`)) {
+    return [`${indent}${key}: |`, ...value.split(`
+`).map((line) => `${indent}  ${line}`)];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return [`${indent}${key}: []`];
+    return [
+      `${indent}${key}:`,
+      ...value.flatMap((item) => {
+        if (item && typeof item === "object") {
+          return [`${indent}  -`, ...Object.entries(item).flatMap(([nestedKey, nestedValue]) => formatYamlValue(nestedKey, nestedValue, `${indent}    `))];
+        }
+        return [`${indent}  - ${formatScalar(item)}`];
+      })
+    ];
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+      return [`${indent}${key}: {}`];
+    return [`${indent}${key}:`, ...entries.flatMap(([nestedKey, nestedValue]) => formatYamlValue(nestedKey, nestedValue, `${indent}  `))];
+  }
+  return [`${indent}${key}: ${formatScalar(value)}`];
+}
+export function buildFrontmatterBlock(skill) {
+  const frontmatter = skill.frontmatter ?? { name: skill.name, description: skill.description };
+  const lines = Object.entries(frontmatter).flatMap(([key, value]) => formatYamlValue(key, value));
+  return ["---", ...lines, "---"].join(`
+`);
+}
+export function buildSkillDocument(skill) {
+  const frontmatter = buildFrontmatterBlock(skill);
+  const content = skill.content.trim();
+  return content ? `${frontmatter}
+
+${content}
+` : `${frontmatter}
+`;
+}
+export function buildEditableSkillDocument(skill, raw) {
+  const source = raw ?? buildSkillDocument(skill);
+  const parsed = parseFrontmatter(source);
+  const frontmatter = { ...parsed.frontmatter };
+  delete frontmatter.name;
+  const editableBlock = ["---", ...Object.entries(frontmatter).flatMap(([key, value]) => formatYamlValue(key, value)), "---"].join(`
+`);
+  const content = stripFrontmatter(source).trim();
+  return content ? `${editableBlock}
+
+${content}
+` : `${editableBlock}
+`;
+}
+export function readSkillDocument(skill) {
+  try {
+    return readFileSync(skill.path, "utf8");
+  } catch {
+    return buildSkillDocument(skill);
+  }
+}
+export function frontmatterToRaw(frontmatter, content) {
+  const block = ["---", ...Object.entries(frontmatter).flatMap(([key, value]) => formatYamlValue(key, value)), "---"].join(`
+`);
+  return content.trim() ? `${block}
+
+${content.trim()}
+` : `${block}
+`;
+}
+export function parseSkillDocument(raw, expectedName) {
+  const parsed = parseFrontmatter(raw);
+  const name = typeof parsed.frontmatter.name === "string" ? parsed.frontmatter.name.trim() : "";
+  const description = typeof parsed.frontmatter.description === "string" ? parsed.frontmatter.description.trim() : "";
+  if (!name || !description)
+    throw new Error("Skill must include frontmatter fields 'name' and 'description'");
+  if (name !== expectedName)
+    throw new Error(`Frontmatter name must stay '${expectedName}'`);
+  const frontmatter = Object.fromEntries(Object.entries(parsed.frontmatter).filter(([, value]) => value !== undefined));
+  const content = stripFrontmatter(raw).trim();
+  return { name, description, frontmatter, content, raw: frontmatterToRaw(frontmatter, content) };
+}
+export function parseEditableSkillDocument(raw, expectedName) {
+  const parsed = parseFrontmatter(raw);
+  if (typeof parsed.frontmatter.name === "string")
+    throw new Error("Name is immutable here. Use Rename instead.");
+  const frontmatter = {
+    name: expectedName,
+    ...Object.fromEntries(Object.entries(parsed.frontmatter).filter(([, value]) => value !== undefined))
+  };
+  const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
+  if (!description)
+    throw new Error("Skill must include frontmatter field 'description'");
+  const content = stripFrontmatter(raw).trim();
+  return { name: expectedName, description, frontmatter, content, raw: frontmatterToRaw(frontmatter, content) };
+}
+export function toUpdatedSkill(skill, parsed) {
+  return { ...skill, name: parsed.name, description: parsed.description, content: parsed.content, frontmatter: parsed.frontmatter };
+}

package/extensions/dm-skills-manager/extensions/skills-manager/glyphs.js

@@ -0,0 +1,142 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+const LOCAL_CONFIG_ID = "@vanillagreen/dm-skills-manager";
+const GLOBAL_CONFIG_ID = "@vanillagreen/pi-tool-renderer";
+function expandHome(input) {
+  if (input === "~")
+    return homedir();
+  if (input.startsWith("~/"))
+    return join(homedir(), input.slice(2));
+  return input;
+}
+function projectSettingsPath(cwd) {
+  let current = resolve(cwd);
+  while (true) {
+    const candidate = join(current, ".dm", "settings.json");
+    if (existsSync(candidate))
+      return candidate;
+    if (existsSync(join(current, ".dm")) || existsSync(join(current, ".git")) || existsSync(join(current, ".kendex-lock.json")))
+      return candidate;
+    const parent = dirname(current);
+    if (parent === current)
+      return join(resolve(cwd), ".dm", "settings.json");
+    current = parent;
+  }
+}
+const PROJECT_TRUST_SYMBOL = Symbol.for("kendex.dm.project-trust");
+function projectTrustRegistry() {
+  const host = globalThis;
+  const existing = host[PROJECT_TRUST_SYMBOL];
+  if (existing)
+    return existing;
+  const created = {};
+  host[PROJECT_TRUST_SYMBOL] = created;
+  return created;
+}
+export function recordProjectTrust(ctx) {
+  if (!ctx.cwd)
+    return;
+  let trusted = true;
+  try {
+    trusted = ctx.isProjectTrusted?.() === true;
+  } catch {
+    trusted = false;
+  }
+  const registry = projectTrustRegistry();
+  if (!registry.projectSettings)
+    registry.projectSettings = new Map;
+  registry.projectSettings.set(projectSettingsPath(ctx.cwd), trusted);
+}
+function projectSettingsTrusted(settingsPath) {
+  return projectTrustRegistry().projectSettings?.get(settingsPath) === true;
+}
+function dmSettingsPaths(cwd = process.cwd()) {
+  const userDir = resolve(expandHome(process.env.PI_CODING_AGENT_DIR?.trim() || "~/.dm/agent"));
+  const user = join(userDir, "settings.json");
+  const project = projectSettingsPath(cwd);
+  return projectSettingsTrusted(project) ? [user, project] : [user];
+}
+function readPackageConfig(packageId, cwd) {
+  const merged = {};
+  for (const settingsPath of dmSettingsPaths(cwd)) {
+    if (!existsSync(settingsPath))
+      continue;
+    try {
+      const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+      const config = parsed?.kendex?.extensionManager?.config?.[packageId];
+      if (config && typeof config === "object" && !Array.isArray(config))
+        Object.assign(merged, config);
+    } catch {}
+  }
+  return merged;
+}
+function asGlyphStyle(value) {
+  return value === "unicode" || value === "ascii" ? value : undefined;
+}
+export function glyphStyle(cwd) {
+  const globalOverride = readPackageConfig(GLOBAL_CONFIG_ID, cwd).globalGlyphStyleOverride;
+  const forced = asGlyphStyle(globalOverride);
+  if (forced)
+    return forced;
+  const local = readPackageConfig(LOCAL_CONFIG_ID, cwd);
+  return asGlyphStyle(local.glyphStyle) ?? asGlyphStyle(local.treeStyle) ?? "unicode";
+}
+export const GLYPHS = {
+  unicode: {
+    frame: { tl: "┏", tr: "┓", bl: "┗", br: "┛", h: "━", v: "┃" },
+    line: "─",
+    tree: { mid: "├─ ", last: "└─ ", stem: "│  ", blank: "   " },
+    bullet: "● ",
+    emptyBullet: "○ ",
+    dot: " · ",
+    ok: "✓",
+    fail: "✗",
+    warn: "▲",
+    diamond: "◆",
+    prompt: "DM",
+    ellipsis: "…",
+    arrow: "→",
+    codeBar: "▌"
+  },
+  ascii: {
+    frame: { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" },
+    line: "-",
+    tree: { mid: "|-- ", last: "`-- ", stem: "|  ", blank: "   " },
+    bullet: "* ",
+    emptyBullet: "o ",
+    dot: " - ",
+    ok: "+",
+    fail: "x",
+    warn: "!",
+    diamond: "*",
+    prompt: "dm",
+    ellipsis: "...",
+    arrow: "->",
+    codeBar: "|"
+  }
+};
+export function glyphs(cwd) {
+  return GLYPHS[glyphStyle(cwd)];
+}
+export function truncateIndicator(cwd) {
+  return glyphs(cwd).ellipsis;
+}
+export function truncateText(text, maxChars, cwd) {
+  if (text.length <= maxChars)
+    return text;
+  const indicator = truncateIndicator(cwd);
+  return `${text.slice(0, Math.max(0, maxChars - indicator.length))}${indicator}`;
+}
+export function dot(cwd) {
+  return glyphs(cwd).dot;
+}
+export function treeGlyph(branch, cwd) {
+  const tree = glyphs(cwd).tree;
+  if (branch === "│")
+    return tree.stem;
+  return branch === "└" ? tree.last : tree.mid;
+}
+export function frameGlyphs(cwd) {
+  return glyphs(cwd).frame;
+}

package/extensions/dm-skills-manager/extensions/skills-manager/layout.js

@@ -0,0 +1,93 @@
+import { DEFAULT_LIST_ROWS, DEFAULT_POPUP_MAX_HEIGHT } from "./constants.js";
+export const BROWSE_FRAME_ROWS = 2;
+export const BROWSE_SEARCH_ROWS = 1;
+export const BROWSE_SEARCH_GAP_ROWS = 1;
+export const BROWSE_FOOTER_GAP_ROWS = 1;
+export const BROWSE_FOOTER_ROWS = 1;
+export const BROWSE_NON_LIST_ROWS = BROWSE_FRAME_ROWS + BROWSE_SEARCH_ROWS + BROWSE_SEARCH_GAP_ROWS + BROWSE_FOOTER_GAP_ROWS + BROWSE_FOOTER_ROWS;
+const DEFAULT_POPUP_MAX_HEIGHT_RATIO = 0.86;
+const FALLBACK_TERMINAL_ROWS = Math.ceil((DEFAULT_LIST_ROWS + BROWSE_NON_LIST_ROWS) / DEFAULT_POPUP_MAX_HEIGHT_RATIO);
+function finiteFloor(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : undefined;
+}
+function positiveFiniteFloor(value) {
+  const floored = finiteFloor(value);
+  return floored !== undefined && floored >= 1 ? floored : undefined;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function parsePopupMaxHeight(maxHeight) {
+  const rows = positiveFiniteFloor(maxHeight);
+  if (rows !== undefined)
+    return { kind: "rows", rows };
+  if (typeof maxHeight !== "string")
+    return;
+  const trimmed = maxHeight.trim();
+  const percent = trimmed.match(/^(\d+(?:\.\d+)?)%$/);
+  if (percent) {
+    const value = Number(percent[1]);
+    if (Number.isFinite(value) && value > 0)
+      return { kind: "percent", ratio: value / 100, text: `${value}%` };
+    return;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const value = Number(trimmed);
+    if (Number.isFinite(value) && value >= 1)
+      return { kind: "rows", rows: value };
+  }
+  return;
+}
+function safeTerminalRows(terminalRows) {
+  return positiveFiniteFloor(terminalRows) ?? FALLBACK_TERMINAL_ROWS;
+}
+function resolvedPopupMaxHeight(maxHeight) {
+  return parsePopupMaxHeight(maxHeight) ?? parsePopupMaxHeight(DEFAULT_POPUP_MAX_HEIGHT) ?? { kind: "percent", ratio: DEFAULT_POPUP_MAX_HEIGHT_RATIO, text: "86%" };
+}
+export function sanitizePopupMaxHeight(maxHeight) {
+  const parsed = parsePopupMaxHeight(maxHeight);
+  if (parsed?.kind === "rows")
+    return parsed.rows;
+  if (parsed?.kind === "percent")
+    return parsed.text;
+  return DEFAULT_POPUP_MAX_HEIGHT;
+}
+export function normalizeListRows(rows, fallback = DEFAULT_LIST_ROWS) {
+  return positiveFiniteFloor(rows) ?? positiveFiniteFloor(fallback) ?? DEFAULT_LIST_ROWS;
+}
+export function resolveOverlayRows(terminalRows, maxHeight = DEFAULT_POPUP_MAX_HEIGHT) {
+  const terminal = safeTerminalRows(terminalRows);
+  const parsed = resolvedPopupMaxHeight(maxHeight);
+  if (parsed.kind === "rows")
+    return Math.max(1, Math.min(terminal, parsed.rows));
+  return Math.max(1, Math.min(terminal, Math.floor(terminal * parsed.ratio)));
+}
+export function responsiveBrowseListRows(configuredRows, terminalRows, maxHeight = DEFAULT_POPUP_MAX_HEIGHT) {
+  const configured = normalizeListRows(configuredRows);
+  const overlayRows = resolveOverlayRows(terminalRows, maxHeight);
+  const availableListRows = Math.max(1, overlayRows - BROWSE_NON_LIST_ROWS);
+  return Math.max(1, Math.min(configured, availableListRows));
+}
+export function browseWindow(entryCount, selectedDisplayIndex, listRows) {
+  const rows = normalizeListRows(listRows);
+  const count = Math.max(0, finiteFloor(entryCount) ?? 0);
+  if (count === 0)
+    return { listRows: rows, startIndex: 0, endIndex: 0 };
+  const selected = clamp(finiteFloor(selectedDisplayIndex) ?? 0, 0, count - 1);
+  const maxStartIndex = Math.max(0, count - rows);
+  const startIndex = clamp(selected - Math.floor(rows / 2), 0, maxStartIndex);
+  return { listRows: rows, startIndex, endIndex: Math.min(startIndex + rows, count) };
+}
+export function responsiveBrowseWindow(configuredRows, terminalRows, entryCount, selectedDisplayIndex, maxHeight = DEFAULT_POPUP_MAX_HEIGHT) {
+  const listRows = responsiveBrowseListRows(configuredRows, terminalRows, maxHeight);
+  return browseWindow(entryCount, selectedDisplayIndex, listRows);
+}
+export function pageBrowseSelection(selectedIndex, maxSelectedIndex, direction, listRows) {
+  const selected = Math.max(0, finiteFloor(selectedIndex) ?? 0);
+  const maxIndex = Math.max(0, finiteFloor(maxSelectedIndex) ?? 0);
+  const step = normalizeListRows(listRows);
+  return clamp(selected + direction * step, 0, maxIndex);
+}
+export function responsiveBrowsePageSelection(configuredRows, terminalRows, selectedIndex, maxSelectedIndex, direction, maxHeight = DEFAULT_POPUP_MAX_HEIGHT) {
+  return pageBrowseSelection(selectedIndex, maxSelectedIndex, direction, responsiveBrowseListRows(configuredRows, terminalRows, maxHeight));
+}

package/extensions/dm-skills-manager/extensions/skills-manager/paths.js

@@ -0,0 +1,76 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getAgentDir } from "@duckmind/dm-coding-agent";
+export function expandHome(input) {
+  if (input === "~")
+    return homedir();
+  if (input.startsWith("~/"))
+    return join(homedir(), input.slice(2));
+  return input;
+}
+export function userDmDir() {
+  return resolve(expandHome(process.env.PI_CODING_AGENT_DIR?.trim() || "~/.dm/agent"));
+}
+export function findProjectDmDir(cwd) {
+  let current = resolve(cwd);
+  while (true) {
+    const candidate = join(current, ".dm");
+    if (existsSync(candidate))
+      return candidate;
+    if (existsSync(join(current, ".git")) || existsSync(join(current, ".kendex-lock.json")))
+      return candidate;
+    const parent = dirname(current);
+    if (parent === current)
+      return join(resolve(cwd), ".dm");
+    current = parent;
+  }
+}
+export function projectSettingsPath(cwd) {
+  return join(findProjectDmDir(cwd), "settings.json");
+}
+const PROJECT_TRUST_SYMBOL = Symbol.for("kendex.dm.project-trust");
+function projectTrustRegistry() {
+  const host = globalThis;
+  const existing = host[PROJECT_TRUST_SYMBOL];
+  if (existing)
+    return existing;
+  const created = {};
+  host[PROJECT_TRUST_SYMBOL] = created;
+  return created;
+}
+export function recordProjectTrust(ctx) {
+  if (!ctx.cwd)
+    return;
+  let trusted = true;
+  try {
+    trusted = ctx.isProjectTrusted?.() === true;
+  } catch {
+    trusted = false;
+  }
+  const registry = projectTrustRegistry();
+  if (!registry.projectSettings)
+    registry.projectSettings = new Map;
+  registry.projectSettings.set(projectSettingsPath(ctx.cwd), trusted);
+}
+export function projectSettingsTrusted(cwd = process.cwd()) {
+  return projectTrustRegistry().projectSettings?.get(projectSettingsPath(cwd)) === true;
+}
+function normalizeDir(path) {
+  const normalized = resolve(path);
+  return normalized.endsWith(sep) ? normalized : normalized + sep;
+}
+function isWithin(path, parent) {
+  return normalizeDir(path).startsWith(normalizeDir(parent));
+}
+export function detectExtensionInstallScope(cwd) {
+  try {
+    const extensionFile = fileURLToPath(import.meta.url);
+    if (isWithin(extensionFile, findProjectDmDir(cwd)))
+      return "project";
+    if (isWithin(extensionFile, getAgentDir()))
+      return "global";
+  } catch {}
+  return "global";
+}

package/extensions/dm-skills-manager/extensions/skills-manager/registry.js

@@ -0,0 +1,95 @@
+import { readFileSync, rmSync } from "node:fs";
+import { basename, dirname } from "node:path";
+import {
+  DefaultPackageManager,
+  getAgentDir,
+  parseFrontmatter,
+  SettingsManager,
+  stripFrontmatter
+} from "@duckmind/dm-coding-agent";
+import { projectSettingsTrusted } from "./paths.js";
+function compareSkills(a, b) {
+  const scopeRank = (scope) => scope === "project" ? 0 : scope === "user" ? 1 : 2;
+  const rank = scopeRank(a.scope) - scopeRank(b.scope);
+  if (rank !== 0)
+    return rank;
+  if (a.origin !== b.origin)
+    return a.origin === "top-level" ? -1 : 1;
+  return a.name.localeCompare(b.name);
+}
+function parseSkillFile(path) {
+  try {
+    const raw = readFileSync(path, "utf8");
+    const { frontmatter } = parseFrontmatter(raw);
+    const name = typeof frontmatter.name === "string" ? frontmatter.name.trim() : "";
+    const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
+    if (!name || !description)
+      return null;
+    return {
+      name,
+      description,
+      content: stripFrontmatter(raw).trim(),
+      frontmatter: Object.fromEntries(Object.entries(frontmatter).filter(([, value]) => value !== undefined))
+    };
+  } catch {
+    return null;
+  }
+}
+function toSkillEntry(resource) {
+  const parsed = parseSkillFile(resource.path);
+  if (!parsed)
+    return null;
+  return {
+    name: parsed.name,
+    description: parsed.description,
+    content: parsed.content,
+    frontmatter: parsed.frontmatter,
+    path: resource.path,
+    scope: resource.metadata.scope,
+    origin: resource.metadata.origin,
+    source: resource.metadata.source,
+    baseDir: resource.metadata.baseDir,
+    enabled: resource.enabled
+  };
+}
+function dedupeByPath(skills) {
+  const seen = new Set;
+  const out = [];
+  for (const skill of skills) {
+    if (seen.has(skill.path))
+      continue;
+    seen.add(skill.path);
+    out.push(skill);
+  }
+  return out;
+}
+export async function loadSkillRegistry(cwd) {
+  const settingsManager = SettingsManager.create(cwd, getAgentDir(), { projectTrusted: projectSettingsTrusted(cwd) });
+  const packageManager = new DefaultPackageManager({ cwd, agentDir: getAgentDir(), settingsManager });
+  const resolved = await packageManager.resolve();
+  const allSkills = dedupeByPath(resolved.skills.map(toSkillEntry).filter((entry) => entry !== null)).sort(compareSkills);
+  const byName = new Map;
+  for (const skill of allSkills) {
+    if (!skill.enabled)
+      continue;
+    if (!byName.has(skill.name))
+      byName.set(skill.name, skill);
+  }
+  const skills = Array.from(byName.values()).sort(compareSkills);
+  return { skills, allSkills, byName: new Map(skills.map((skill) => [skill.name, skill])) };
+}
+export function isDeletableSkill(skill) {
+  return skill.origin === "top-level" && (skill.scope === "project" || skill.scope === "user");
+}
+export function skillStorageTarget(skill) {
+  return basename(skill.path).toLowerCase() === "skill.md" ? dirname(skill.path) : skill.path;
+}
+export async function deleteSkill(ctx, skill) {
+  if (!isDeletableSkill(skill)) {
+    ctx.ui.notify("Only your own project and global skills can be deleted", "warning");
+    return false;
+  }
+  rmSync(skillStorageTarget(skill), { recursive: true, force: true });
+  ctx.ui.notify(`Deleted skill: ${skill.name}`, "info");
+  return true;
+}

package/extensions/dm-skills-manager/extensions/skills-manager/settings.js

@@ -0,0 +1,93 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { PACKAGE_ID } from "./constants.js";
+import { detectExtensionInstallScope, projectSettingsPath, projectSettingsTrusted, userDmDir } from "./paths.js";
+export function readJsonObject(path) {
+  if (!existsSync(path))
+    return { path, json: {}, exists: false };
+  const text = readFileSync(path, "utf8");
+  if (!text.trim())
+    return { path, json: {}, exists: true };
+  const parsed = JSON.parse(text);
+  return { path, json: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {}, exists: true };
+}
+export function writeJsonFile(file) {
+  mkdirSync(dirname(file.path), { recursive: true });
+  writeFileSync(file.path, `${JSON.stringify(file.json, null, 2)}
+`, "utf8");
+  file.exists = true;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function getOrCreateRecord(parent, key) {
+  const current = asRecord(parent[key]);
+  if (current)
+    return current;
+  const created = {};
+  parent[key] = created;
+  return created;
+}
+function piSettingsFiles(cwd = process.cwd()) {
+  const user = readJsonObject(join(userDmDir(), "settings.json"));
+  return projectSettingsTrusted(cwd) ? [user, readJsonObject(projectSettingsPath(cwd))] : [user];
+}
+function packageConfigFromFile(file) {
+  return asRecord(asRecord(asRecord(file.json.kendex)?.extensionManager)?.config)?.[PACKAGE_ID];
+}
+function readkendexConfig(cwd = process.cwd()) {
+  const merged = {};
+  for (const file of piSettingsFiles(cwd)) {
+    const config = packageConfigFromFile(file);
+    if (config && typeof config === "object" && !Array.isArray(config))
+      Object.assign(merged, config);
+  }
+  return merged;
+}
+export function settingBoolean(key, fallback, cwd = process.cwd()) {
+  const value = readkendexConfig(cwd)[key];
+  return typeof value === "boolean" ? value : fallback;
+}
+export function settingString(key, fallback, cwd = process.cwd()) {
+  const value = readkendexConfig(cwd)[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+export function settingNumber(key, fallback, cwd = process.cwd()) {
+  const value = readkendexConfig(cwd)[key];
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+export function settingOverlaySize(key, fallback, cwd = process.cwd()) {
+  const value = readkendexConfig(cwd)[key];
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const trimmed = value.trim();
+    if (/^\d+$/.test(trimmed))
+      return Number(trimmed);
+    if (/^\d+(?:\.\d+)?%$/.test(trimmed))
+      return trimmed;
+  }
+  return fallback;
+}
+function writeScopeForConfigKey(cwd, key) {
+  const [user, project] = piSettingsFiles(cwd);
+  if (project && packageConfigFromFile(project)?.[key] !== undefined)
+    return "project";
+  if (packageConfigFromFile(user)?.[key] !== undefined)
+    return "global";
+  const detected = detectExtensionInstallScope(cwd);
+  return detected === "project" && !projectSettingsTrusted(cwd) ? "global" : detected;
+}
+export function updatePackageConfig(cwd, updates, scope) {
+  const firstKey = Object.keys(updates)[0] ?? "enabled";
+  const targetScope = scope ?? writeScopeForConfigKey(cwd, firstKey);
+  const path = targetScope === "global" ? join(userDmDir(), "settings.json") : projectSettingsPath(cwd);
+  const file = readJsonObject(path);
+  const kendex = getOrCreateRecord(file.json, "kendex");
+  const extensionManager = getOrCreateRecord(kendex, "extensionManager");
+  const config = getOrCreateRecord(extensionManager, "config");
+  const packageConfig = getOrCreateRecord(config, PACKAGE_ID);
+  Object.assign(packageConfig, updates);
+  writeJsonFile(file);
+}

package/extensions/dm-skills-manager/extensions/skills-manager/startup.js

@@ -0,0 +1,32 @@
+import { InteractiveMode } from "@duckmind/dm-coding-agent";
+import { STARTUP_HIDE_ENABLED_SYMBOL, STARTUP_PATCH_SYMBOL } from "./constants.js";
+export function setStartupHideEnabled(enabled) {
+  globalThis[STARTUP_HIDE_ENABLED_SYMBOL] = enabled;
+}
+function startupHideEnabled() {
+  return globalThis[STARTUP_HIDE_ENABLED_SYMBOL] === true;
+}
+export function patchInteractiveModeStartupSkillsBlock() {
+  const prototype = InteractiveMode.prototype;
+  if (prototype[STARTUP_PATCH_SYMBOL])
+    return;
+  const originalShowLoadedResources = prototype.showLoadedResources;
+  if (typeof originalShowLoadedResources !== "function")
+    return;
+  prototype.showLoadedResources = function patchedShowLoadedResources(...args) {
+    if (!startupHideEnabled())
+      return originalShowLoadedResources.apply(this, args);
+    const interactiveMode = this;
+    const resourceLoader = interactiveMode.session?.resourceLoader;
+    if (!resourceLoader || typeof resourceLoader.getSkills !== "function")
+      return originalShowLoadedResources.apply(this, args);
+    const originalGetSkills = resourceLoader.getSkills;
+    resourceLoader.getSkills = () => ({ ...originalGetSkills.call(resourceLoader), skills: [] });
+    try {
+      return originalShowLoadedResources.apply(this, args);
+    } finally {
+      resourceLoader.getSkills = originalGetSkills;
+    }
+  };
+  prototype[STARTUP_PATCH_SYMBOL] = true;
+}