@duckmind/dm-windows-x64 0.63.4 → 0.63.9

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

@@ -0,0 +1,145 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join } from "node:path";
+import { GENERATE_SKILL_SYSTEM_PROMPT } from "./constants.js";
+import { frontmatterToRaw, getTargetDir, normalizeSkillName, parseSkillDocument } from "./format.js";
+import { isDeletableSkill } from "./registry.js";
+import { settingBoolean } from "./settings.js";
+import { completeSimple, retrySkillGenerationCompat } from "./dm-ai-compat.js";
+import { resolveSkillDraft } from "./creation-fallback.js";
+function buildFallbackSkill(answers) {
+  const frontmatter = { name: answers.name, description: answers.description };
+  if (answers.allowedTools.length > 0)
+    frontmatter["allowed-tools"] = answers.allowedTools.join(" ");
+  const sections = [
+    frontmatterToRaw(frontmatter, "").trim(),
+    `# ${answers.name}`,
+    "## Core workflow",
+    "- Confirm the request matches the skill description and the user's current goal.",
+    "- Inspect relevant inputs before acting; do not assume project-specific conventions without evidence.",
+    "- Apply the most direct workflow for the task and keep outputs concrete.",
+    "- Call out important edge cases, constraints, and verification steps before finishing."
+  ];
+  if (answers.exampleRequests?.trim())
+    sections.push("## Example requests", answers.exampleRequests.trim());
+  if (answers.domainContext?.trim())
+    sections.push("## Domain context", answers.domainContext.trim());
+  return `${sections.join(`
+
+`).trim()}
+`;
+}
+function getEffectiveReasoningLevel(ctx, thinkingLevel) {
+  if (!ctx.model?.reasoning || !thinkingLevel || thinkingLevel === "off")
+    return;
+  return thinkingLevel;
+}
+export async function generateSkillDraft(ctx, answers, options, deps = {}) {
+  if (options?.signal?.aborted)
+    throw new Error("Generation aborted");
+  if (!settingBoolean("aiGenerationEnabled", true, ctx.cwd) || !ctx.model)
+    return buildFallbackSkill(answers);
+  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+  if (!auth.ok)
+    return buildFallbackSkill(answers);
+  const userMessage = {
+    role: "user",
+    content: [{
+      type: "text",
+      text: [
+        "Create a DM skill SKILL.md.",
+        "",
+        "Inputs:",
+        `- skill_slug: ${answers.name}`,
+        `- requested_description: ${answers.description}`,
+        `- save_location: ${answers.location}`,
+        answers.allowedTools.length > 0 ? `- allowed_tools: ${answers.allowedTools.join(" ")}` : "- allowed_tools: (none)",
+        `- example_requests: ${answers.exampleRequests?.trim() || "(none)"}`,
+        `- domain_context: ${answers.domainContext?.trim() || "(none)"}`,
+        "",
+        "Make the description specific enough for DM's skill trigger list. Keep the body compact and execution-oriented."
+      ].join(`
+`)
+    }],
+    timestamp: Date.now()
+  };
+  const reasoning = getEffectiveReasoningLevel(ctx, options?.thinkingLevel);
+  const response = await (deps.retrySkillGeneration ?? retrySkillGenerationCompat)(() => (deps.completeSimple ?? completeSimple)(ctx.model, { systemPrompt: GENERATE_SKILL_SYSTEM_PROMPT, messages: [userMessage] }, { apiKey: auth.apiKey, env: auth.env, headers: auth.headers, ...reasoning ? { reasoning } : {}, ...options?.signal ? { signal: options.signal } : {} }), options?.signal, (attempt, maxAttempts, delayMs, errorMessage) => {
+    ctx.ui.notify(`Skill generation retry ${attempt}/${maxAttempts} in ${Math.ceil(delayMs / 1000)}s: ${errorMessage}`, "warning");
+  });
+  if (options?.signal?.aborted)
+    throw new Error("Generation aborted");
+  if (response.stopReason === "error" || response.stopReason === "aborted")
+    throw new Error(response.errorMessage || `Generation stopped: ${response.stopReason}`);
+  const generated = response.content.filter((c) => typeof c === "object" && c !== null && c.type === "text").map((c) => c.text).join(`
+`).trim();
+  if (!generated)
+    throw new Error("Skill generation returned no text");
+  parseSkillDocument(generated, answers.name);
+  return generated;
+}
+async function saveCreatedSkill(ctx, answers, draft) {
+  let parsed;
+  try {
+    parsed = parseSkillDocument(draft, answers.name);
+  } catch (error) {
+    ctx.ui.notify(error instanceof Error ? error.message : "Invalid generated SKILL.md", "error");
+    return null;
+  }
+  const targetDir = getTargetDir(ctx, answers.location, answers.name);
+  const targetPath = join(targetDir, "SKILL.md");
+  await mkdir(targetDir, { recursive: true });
+  await writeFile(targetPath, parsed.raw, "utf8");
+  ctx.ui.notify(`Created skill: ${targetPath}`, "info");
+  return {
+    name: parsed.name,
+    description: parsed.description,
+    path: targetPath,
+    content: parsed.content,
+    frontmatter: parsed.frontmatter,
+    scope: answers.location === "global" ? "user" : "project",
+    origin: "top-level",
+    source: "auto",
+    baseDir: targetDir,
+    enabled: true
+  };
+}
+export async function createSkillFromAnswers(ctx, answers, options, deps = {}) {
+  const targetPath = join(getTargetDir(ctx, answers.location, answers.name), "SKILL.md");
+  if (existsSync(targetPath)) {
+    ctx.ui.notify(`Skill already exists: ${targetPath}`, "error");
+    return null;
+  }
+  const draft = await resolveSkillDraft(() => generateSkillDraft(ctx, answers, options, deps), () => buildFallbackSkill(answers), options?.signal, (error) => ctx.ui.notify(`AI skill generation failed; using fallback template: ${error instanceof Error ? error.message : String(error)}`, "warning"));
+  if (draft === null)
+    return null;
+  return await saveCreatedSkill(ctx, answers, draft);
+}
+export async function renameSkillEntry(ctx, skill, entered) {
+  if (!isDeletableSkill(skill)) {
+    ctx.ui.notify("Only your own project and global skills can be renamed", "warning");
+    return null;
+  }
+  const normalizedName = normalizeSkillName(entered);
+  if (!normalizedName)
+    throw new Error("Name must contain letters, numbers, or hyphens");
+  if (normalizedName === skill.name) {
+    ctx.ui.notify("Skill name unchanged", "info");
+    return skill;
+  }
+  const isDirectorySkill = basename(skill.path).toLowerCase() === "skill.md";
+  const currentTarget = isDirectorySkill ? dirname(skill.path) : skill.path;
+  const parentDir = dirname(currentTarget);
+  const targetPath = isDirectorySkill ? join(parentDir, normalizedName, "SKILL.md") : join(parentDir, `${normalizedName}${extname(skill.path) || ".md"}`);
+  const targetTarget = isDirectorySkill ? dirname(targetPath) : targetPath;
+  if (existsSync(targetTarget) || existsSync(targetPath))
+    throw new Error(`Skill already exists: ${normalizedName}`);
+  const parsed = parseSkillDocument(readFileSync(skill.path, "utf8"), skill.name);
+  const renamedFrontmatter = { ...parsed.frontmatter, name: normalizedName };
+  const updatedRaw = frontmatterToRaw(renamedFrontmatter, parsed.content);
+  renameSync(currentTarget, targetTarget);
+  writeFileSync(targetPath, updatedRaw, "utf8");
+  const renamed = { ...skill, name: normalizedName, path: targetPath, frontmatter: renamedFrontmatter, baseDir: isDirectorySkill ? dirname(targetPath) : dirname(targetPath) };
+  ctx.ui.notify(`Renamed skill: ${skill.name} → ${normalizedName}`, "info");
+  return renamed;
+}