cue-ai 0.9.0 → 0.9.2

package/src/lib/trigger-gaps.ts

@@ -45,10 +45,40 @@ export interface ComputeGapsInput {
    * triggers (e.g. `"go"`) matching every prompt. Default 4.
    */
   minTriggerLength?: number;
+  /**
+   * A bare single-word trigger (e.g. "help", "analyze") that isn't a
+   * slash-command only counts as a match when the prompt is at most this many
+   * characters — i.e. the word plausibly *is* the request, not a substring of a
+   * longer unrelated prompt. Multi-word and slash-command triggers match at any
+   * length. Default 80.
+   */
+  weakTriggerMaxPromptChars?: number;
   /** Cap on returned rows (sorted by gap DESC). Default 10. */
   limit?: number;
 }
 
+const DEFAULT_MIN_TRIGGER_LENGTH = 4;
+const DEFAULT_WEAK_TRIGGER_MAX_PROMPT_CHARS = 80;
+
+/** A trigger is "weak" when it's a single bare word (no spaces) and not a
+ *  slash-command — these are the ones that drown the metric in substring noise
+ *  ("help" inside "help me", "analyze" inside "reanalyze"). */
+function isWeakTrigger(triggerLower: string): boolean {
+  return !/\s/.test(triggerLower) && !triggerLower.startsWith("/");
+}
+
+/**
+ * Compile a trigger into a word-boundary matcher. Plain `String.includes` (the
+ * old behavior) matched "analyze" inside "reanalyze" and "help" inside
+ * "helpful"; `\b` doesn't work for triggers with leading punctuation
+ * ("/caveman") or internal hyphens ("agent-to-agent"), so we anchor on
+ * alphanumeric look-arounds instead: the trigger must not abut a word char.
+ */
+function compileTrigger(triggerLower: string): RegExp {
+  const escaped = triggerLower.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?<![a-z0-9_])${escaped}(?![a-z0-9_])`);
+}
+
 /**
  * Compute the per-skill gap table. Designed for "user mostly says these
  * things, here's which skills should fire but aren't" — not a high-precision
@@ -56,22 +86,34 @@ export interface ComputeGapsInput {
  * surface real problems when the gap count is large.
  */
 export function computeTriggerGaps(input: ComputeGapsInput): TriggerGapRow[] {
-  const minLen = input.minTriggerLength ?? 4;
+  const minLen = input.minTriggerLength ?? DEFAULT_MIN_TRIGGER_LENGTH;
   const limit = input.limit ?? 10;
-  const promptsLower = input.userPrompts.map((p) => p.toLowerCase());
+  const weakMaxChars = input.weakTriggerMaxPromptChars ?? DEFAULT_WEAK_TRIGGER_MAX_PROMPT_CHARS;
+  // Keep each prompt's length alongside its lowercased text for the weak-trigger
+  // proportion check.
+  const prompts = input.userPrompts.map((p) => ({ text: p.toLowerCase(), len: p.length }));
 
   const rows: TriggerGapRow[] = [];
   for (const skill of input.skills) {
-    const triggers = (skill.triggers ?? []).filter((t) => t.length >= minLen);
+    // Precompile each trigger's word-boundary matcher once (15k+ prompts × N
+    // triggers per skill — compiling per prompt would be wasteful).
+    const triggers = (skill.triggers ?? [])
+      .filter((t) => t.length >= minLen)
+      .map((t) => {
+        const lower = t.toLowerCase();
+        return { raw: t, re: compileTrigger(lower), weak: isWeakTrigger(lower) };
+      });
     if (triggers.length === 0) continue;
 
     let matched = 0;
     const samples = new Set<string>();
-    for (const prompt of promptsLower) {
+    for (const prompt of prompts) {
       for (const t of triggers) {
-        if (prompt.includes(t.toLowerCase())) {
+        // A bare single word only counts when it dominates a short prompt.
+        if (t.weak && prompt.len > weakMaxChars) continue;
+        if (t.re.test(prompt.text)) {
           matched++;
-          if (samples.size < 3) samples.add(t);
+          if (samples.size < 3) samples.add(t.raw);
           break;
         }
       }

package/src/lib/tui/data.ts

@@ -12,6 +12,7 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { configDir } from "../config-paths";
 
 import { listProfiles, loadProfile } from "../profile-loader";
 import { resolveProfileForCwd } from "../cwd-resolver";
@@ -43,11 +44,6 @@ function repoRoot(): string {
   return resolve(here, "..", "..", "..");
 }
 
-function configDir(): string {
-  return process.env.XDG_CONFIG_HOME
-    ? join(process.env.XDG_CONFIG_HOME, "cue")
-    : join(homedir(), ".config", "cue");
-}
 
 function skillsRoot(): string {
   return join(repoRoot(), "resources", "skills", "skills");

package/src/lib/workflow-store.ts

@@ -0,0 +1,150 @@
+/**
+ * Cue workflow store — the on-disk format + CRUD for visually-authored
+ * Claude Code workflows (the n8n-style canvas in cue studio).
+ *
+ * A workflow is a DAG of cue primitives (skills, commands, subagents, MCP
+ * tools) saved as resources/workflows/<name>.json. The shape is deliberately
+ * React-Flow-compatible (nodes carry id + position, edges carry source/target
+ * + handles) so the studio canvas can load/save with no translation layer.
+ *
+ * This module is pure storage + validation; execution lives in a separate
+ * runtime (M4). Read-only callers (list/load) never throw; writes validate the
+ * name and shape and throw WorkflowError on bad input.
+ */
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const REPO_ROOT = resolve(new URL(import.meta.url).pathname, "..", "..", "..");
+
+/** Where workflow JSON lives. Honors the same env override as profiles. */
+export function workflowsDir(): string {
+  return process.env.CUE_WORKFLOWS_DIR ?? join(REPO_ROOT, "resources", "workflows");
+}
+
+export type WorkflowNodeKind =
+  | "trigger"   // entry point (manual / on-message / cron) — no cue ref
+  | "skill"     // a cue skill, e.g. "meta/analyze"
+  | "command"   // a slash command, e.g. "goal"
+  | "subagent"  // a delegatable specialist
+  | "mcp"       // an MCP tool call, e.g. lightpanda.goto
+  | "note";     // a free-text sticky, no execution
+
+export interface WorkflowNode {
+  /** Unique within the workflow (React Flow node id). */
+  id: string;
+  kind: WorkflowNodeKind;
+  /** The cue primitive this node invokes (skill id / command / subagent / "mcp:tool"). Empty for trigger/note. */
+  ref: string;
+  /** Display label on the canvas. */
+  label: string;
+  position: { x: number; y: number };
+  /** Per-node params: prompt, args, the chosen MCP tool, etc. */
+  config?: Record<string, unknown>;
+}
+
+export interface WorkflowEdge {
+  id: string;
+  source: string;
+  target: string;
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+}
+
+export interface CueWorkflow {
+  version: 1;
+  /** Slug, equal to the filename stem. */
+  name: string;
+  title: string;
+  description: string;
+  nodes: WorkflowNode[];
+  edges: WorkflowEdge[];
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface WorkflowSummary {
+  name: string;
+  title: string;
+  description: string;
+  nodeCount: number;
+  edgeCount: number;
+  updatedAt: string | null;
+}
+
+export class WorkflowError extends Error {}
+
+const NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+/** Validate a workflow name: slug only, no path traversal. */
+export function assertValidName(name: string): void {
+  if (!NAME_RE.test(name) || name.includes("..") || name.length > 64) {
+    throw new WorkflowError(`invalid workflow name: ${name}`);
+  }
+}
+
+function readJson<T>(path: string): T | null {
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as T;
+  } catch {
+    return null;
+  }
+}
+
+/** Every saved workflow, newest-updated first. Never throws. */
+export function listWorkflows(): WorkflowSummary[] {
+  const dir = workflowsDir();
+  if (!existsSync(dir)) return [];
+  const out: WorkflowSummary[] = [];
+  for (const f of readdirSync(dir)) {
+    if (!f.endsWith(".json")) continue;
+    const wf = readJson<CueWorkflow>(join(dir, f));
+    if (!wf || typeof wf.name !== "string") continue;
+    out.push({
+      name: wf.name,
+      title: wf.title ?? wf.name,
+      description: wf.description ?? "",
+      nodeCount: Array.isArray(wf.nodes) ? wf.nodes.length : 0,
+      edgeCount: Array.isArray(wf.edges) ? wf.edges.length : 0,
+      updatedAt: wf.updatedAt ?? null,
+    });
+  }
+  return out.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+}
+
+/** Load one workflow by name, or null when absent/corrupt. */
+export function loadWorkflow(name: string): CueWorkflow | null {
+  assertValidName(name);
+  return readJson<CueWorkflow>(join(workflowsDir(), `${name}.json`));
+}
+
+/**
+ * Validate + persist a workflow. `nowIso` is injected (the dashboard server
+ * stamps it) so this module stays free of wall-clock calls. Returns the saved
+ * doc with timestamps applied.
+ */
+export function saveWorkflow(input: unknown, nowIso: string): CueWorkflow {
+  const wf = input as Partial<CueWorkflow>;
+  if (!wf || typeof wf !== "object") throw new WorkflowError("workflow must be an object");
+  if (typeof wf.name !== "string") throw new WorkflowError("workflow.name is required");
+  assertValidName(wf.name);
+  if (!Array.isArray(wf.nodes)) throw new WorkflowError("workflow.nodes must be an array");
+  if (!Array.isArray(wf.edges)) throw new WorkflowError("workflow.edges must be an array");
+
+  const dir = workflowsDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const existing = loadWorkflow(wf.name);
+
+  const doc: CueWorkflow = {
+    version: 1,
+    name: wf.name,
+    title: wf.title ?? wf.name,
+    description: wf.description ?? "",
+    nodes: wf.nodes as WorkflowNode[],
+    edges: wf.edges as WorkflowEdge[],
+    createdAt: existing?.createdAt ?? nowIso,
+    updatedAt: nowIso,
+  };
+  writeFileSync(join(dir, `${wf.name}.json`), JSON.stringify(doc, null, 2) + "\n");
+  return doc;
+}

package/src/lib/workspace-secrets.ts

@@ -25,10 +25,6 @@ function storePath(): string {
   return join(secretsDir(), "workspace-secrets.json.age");
 }
 
-function plainStorePath(): string {
-  return join(secretsDir(), "workspace-secrets.json");
-}
-
 function hasAge(): boolean {
   try {
     execSync("which age", { stdio: "pipe" });

package/src/lib/workspaces.ts

@@ -7,7 +7,7 @@
  * or via `cue workspace <name>`.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, } from "node:fs";
 import { join, dirname } from "node:path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";