agileflow 4.0.0-alpha.2 → 4.0.0-alpha.21

package/src/cli/commands/learn.js

@@ -0,0 +1,149 @@
+/**
+ * `agileflow learn append|list <skill-id>` — manage skill learnings.
+ *
+ * Skills with `learns.enabled: true` in their frontmatter accumulate
+ * persistent signals (user corrections, accepted patterns) in the
+ * installed skill directory. This subcommand is the write/read entry
+ * point — atomic, capped, and skill-aware.
+ *
+ * Usage:
+ *   agileflow learn append <skill-id> "<observation>" [--confidence high|medium|low] [--source correction|confirmation|observation]
+ *   agileflow learn list   <skill-id>
+ */
+const path = require("path");
+const {
+  appendLearning,
+  readLearnings,
+} = require("../../runtime/skills/learnings.js");
+const { discoverPlugins } = require("../../runtime/plugins/registry.js");
+const { loadSkill } = require("../../runtime/skills/validator.js");
+const {
+  InvalidArgumentError,
+  OperationFailedError,
+  fail,
+} = require("../../lib/errors.js");
+
+const CONFIDENCE_ORDER = { high: 0, medium: 1, low: 2 };
+
+/**
+ * Walk discovered plugins to find the skill manifest and return its
+ * learnings config. Throws when the skill is unknown or has not opted
+ * into learnings.
+ *
+ * @param {string} skillId
+ * @returns {Promise<{ file?: string, maxEntries: number }>}
+ */
+async function resolveLearnsConfig(skillId) {
+  const plugins = discoverPlugins();
+  for (const plugin of plugins) {
+    const skills = (plugin.provides && plugin.provides.skills) || [];
+    for (const s of skills) {
+      if (!s || s.id !== skillId) continue;
+      const skillDir = s.dir ? path.join(plugin.dir, s.dir) : null;
+      if (!skillDir) continue;
+      const manifest = await loadSkill(path.join(skillDir, "SKILL.md"));
+      const learns = manifest.frontmatter && manifest.frontmatter.learns;
+      if (!learns || learns.enabled !== true) {
+        throw new InvalidArgumentError(
+          `skill "${skillId}" does not have learns.enabled: true`,
+          {
+            suggestion: `set \`learns.enabled: true\` in the skill's SKILL.md frontmatter`,
+          },
+        );
+      }
+      const file =
+        typeof learns.file === "string" && learns.file
+          ? learns.file
+          : undefined;
+      const maxEntries =
+        Number.isInteger(learns.maxEntries) && learns.maxEntries > 0
+          ? learns.maxEntries
+          : 50;
+      return { file, maxEntries };
+    }
+  }
+  throw new InvalidArgumentError(`unknown skill: "${skillId}"`, {
+    suggestion: `run \`agileflow skills list\` to see installed skills`,
+  });
+}
+
+/**
+ * @param {string} action - 'append' | 'list'
+ * @param {string} skillId
+ * @param {string} [observation]
+ * @param {{ confidence?: string, source?: string }} [options]
+ */
+async function learn(action, skillId, observation, options = {}) {
+  const projectDir = process.cwd();
+
+  let cfg;
+  try {
+    cfg = await resolveLearnsConfig(skillId);
+  } catch (err) {
+    fail(err, { command: "learn" });
+  }
+
+  if (action === "append") {
+    if (!observation || !observation.trim()) {
+      fail(
+        new InvalidArgumentError("append requires an observation", {
+          suggestion:
+            'agileflow learn append <skill-id> "<observation>" [--confidence high|medium|low] [--source correction|confirmation|observation]',
+        }),
+        { command: "learn" },
+      );
+    }
+    try {
+      await appendLearning(
+        skillId,
+        projectDir,
+        {
+          observation,
+          confidence: options.confidence || "medium",
+          source: options.source || "correction",
+        },
+        { maxEntries: cfg.maxEntries },
+      );
+    } catch (err) {
+      fail(
+        new OperationFailedError(`could not append learning: ${err.message}`, {
+          suggestion: "check write permissions on the skill directory",
+          cause: err,
+        }),
+        { command: "learn" },
+      );
+    }
+    const { entries } = await readLearnings(skillId, projectDir);
+    // eslint-disable-next-line no-console
+    console.log(`✓ learning saved (${entries.length} total) for ${skillId}`);
+    return;
+  }
+
+  if (action === "list") {
+    const { entries } = await readLearnings(skillId, projectDir);
+    if (!entries.length) {
+      // eslint-disable-next-line no-console
+      console.log(`(no learnings yet for ${skillId})`);
+      return;
+    }
+    const sorted = [...entries].sort(
+      (a, b) =>
+        (CONFIDENCE_ORDER[a.confidence] ?? 99) -
+        (CONFIDENCE_ORDER[b.confidence] ?? 99),
+    );
+    for (const e of sorted) {
+      // eslint-disable-next-line no-console
+      console.log(`[${e.created}] (${e.confidence}) ${e.observation}`);
+    }
+    return;
+  }
+
+  fail(
+    new InvalidArgumentError(`unknown action "${action}"`, {
+      suggestion: "use `agileflow learn append` or `agileflow learn list`",
+    }),
+    { command: "learn" },
+  );
+}
+
+module.exports = learn;

package/src/cli/commands/plugins.js

@@ -0,0 +1,113 @@
+/**
+ * `agileflow plugins <action>` — inspect the plugin registry.
+ *
+ * Actions:
+ *   list   Print all discoverable plugins with enabled status, skill count,
+ *          and description. Reads agileflow.config.json for the enable state;
+ *          falls back to the plugin's `enabledByDefault` flag when no config
+ *          is present.
+ *
+ * Usage:
+ *   agileflow plugins list
+ *   agileflow plugins list --json
+ */
+const path = require("path");
+const { loadConfig } = require("../../runtime/config/loader.js");
+const { discoverPlugins } = require("../../runtime/plugins/registry.js");
+const { InvalidArgumentError, fail } = require("../../lib/errors.js");
+
+/**
+ * @param {string} action - 'list'
+ * @param {{ json?: boolean }} options
+ */
+async function plugins(action, options = {}) {
+  if (action !== "list") {
+    fail(
+      new InvalidArgumentError(`unknown action "${action}"`, {
+        suggestion: "agileflow plugins list",
+      }),
+      { command: "plugins" },
+    );
+  }
+
+  const cwd = process.cwd();
+  const { config, source } = await loadConfig(cwd);
+  const configPlugins = source === "file" ? config.plugins || {} : {};
+
+  const discovered = discoverPlugins();
+
+  const rows = discovered.map((p) => {
+    const cfgEntry = configPlugins[p.id];
+    let enabled;
+    if (cfgEntry !== undefined) {
+      enabled = Boolean(cfgEntry && cfgEntry.enabled);
+    } else {
+      enabled = Boolean(p.enabledByDefault) || Boolean(p.cannotDisable);
+    }
+
+    const skillCount =
+      p.provides && p.provides.skills ? p.provides.skills.length : 0;
+    const description = (p.description || "")
+      .replace(/\n/g, " ")
+      .trim()
+      .slice(0, 72);
+
+    return {
+      id: p.id,
+      enabled,
+      cannotDisable: Boolean(p.cannotDisable),
+      skills: skillCount,
+      description,
+    };
+  });
+
+  if (options.json) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({ source, plugins: rows }, null, 2));
+    return;
+  }
+
+  const idW = Math.max(6, ...rows.map((r) => r.id.length));
+  const statusW = 8; // "disabled" length
+  const skillsW = 6; // "skills" length
+
+  const header = `${"Plugin".padEnd(idW)}  ${"Status".padEnd(statusW)}  ${"Skills".padEnd(skillsW)}  Description`;
+  const sep = `${"-".repeat(idW)}  ${"-".repeat(statusW)}  ${"-".repeat(skillsW)}  ${"-".repeat(40)}`;
+
+  // eslint-disable-next-line no-console
+  console.log("\nAvailable plugins:\n");
+  // eslint-disable-next-line no-console
+  console.log(header);
+  // eslint-disable-next-line no-console
+  console.log(sep);
+
+  for (const r of rows) {
+    const status = r.cannotDisable
+      ? "always  "
+      : r.enabled
+        ? "enabled "
+        : "disabled";
+    const skillsStr = String(r.skills).padEnd(skillsW);
+    // eslint-disable-next-line no-console
+    console.log(
+      `${r.id.padEnd(idW)}  ${status}  ${skillsStr}  ${r.description}`,
+    );
+  }
+
+  const enabledCount = rows.filter((r) => r.enabled || r.cannotDisable).length;
+  // eslint-disable-next-line no-console
+  console.log(`\n${rows.length} plugin(s) available, ${enabledCount} enabled.`);
+  if (source === "defaults") {
+    // eslint-disable-next-line no-console
+    console.log(
+      "  (no agileflow.config.json — showing defaults; run `agileflow setup` to configure)",
+    );
+  } else {
+    // eslint-disable-next-line no-console
+    console.log(
+      "  Use `agileflow skills enable <plugin>` or `agileflow skills disable <plugin>` to change.",
+    );
+  }
+}
+
+module.exports = plugins;