@lazyingart/agintiflow 0.20.80 → 0.20.82

package/README.md

@@ -270,7 +270,7 @@ Inside chat:
 /aaps dry-run workflows/main.aaps
 ```
 
-Use AAPS when the task is bigger than a single chat: app development with stages, paper/book workflows, validation gates, recovery steps, artifact production, or top-down agentic scripts. See [docs/aaps.md](docs/aaps.md) and the package [https://www.npmjs.com/package/@lazyingart/aaps](https://www.npmjs.com/package/@lazyingart/aaps).
+Use AAPS when the task is bigger than a single chat: app development with stages, paper/book workflows, validation gates, recovery steps, artifact production, or top-down agentic scripts. The current adapter is intentionally lightweight: prompt-only AAPS tasks are reported as handoffs and do not automatically execute an LLM/backend agent yet, so AgInTiFlow warns when a run has no executable steps or misses a declared output. See [docs/aaps.md](docs/aaps.md) and the package [https://www.npmjs.com/package/@lazyingart/aaps](https://www.npmjs.com/package/@lazyingart/aaps).
 
 ## Local API Quick Reference
 

package/docs/aaps.md

@@ -42,6 +42,8 @@ The adapter keeps paths project-relative and uses `execFile`, not shell interpol
 
 `compile check` and `validate` are the recommended first checks. `run` can execute commands declared by the `.aaps` workflow, so treat it like any other project execution step and run only workflows you intend to execute.
 
+Current lightweight adapter boundary: prompt-only AAPS tasks are recorded as handoffs. They do not automatically call an LLM/backend agent yet. When a workflow has prompt-only steps, `aginti aaps run` and `aginti aaps dry-run` print `promptOnly=<n>` plus warnings if no executable steps ran or a declared output was not produced.
+
 `aginti aaps install` installs `@lazyingart/aaps` as a project dev dependency only when the current project has `package.json`. Use `aginti aaps install global` only when you intentionally want a global npm install.
 
 ## Project Shape
@@ -56,7 +58,7 @@ runs/
 artifacts/
 ```
 
-The starter workflow is deliberately simple: it defines a planner agent and a `draft_plan` task that writes `reports/aaps-plan.md`. Use it as a safe scaffold, then expand the workflow with blocks, validations, recovery steps, and review gates.
+The starter workflow is deliberately simple: it defines a planner agent and a `draft_plan` task whose declared output is `reports/aaps-plan.md`. With the current lightweight adapter this task is prompt-only, so `run` produces durable run metadata and a handoff warning rather than writing the plan itself. Use AgInTiFlow to act on that handoff, or expand the workflow with executable actions, validations, recovery steps, and review gates.
 
 ## When To Use AAPS
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.80",
+  "version": "0.20.82",
   "type": "module",
   "description": "Low-cost, project-aware Web and CLI agents with DeepSeek/Venice/OpenAI routing, visible tool calls, durable sessions, scouts, AAPS, SCS, and guarded local execution.",
   "license": "Apache-2.0",

package/scripts/smoke-aaps-adapter.js

@@ -45,6 +45,21 @@ if (discovery.found) {
   const compile = await runAapsAction("compile", ["check"], { cwd: tempRoot, packageDir: repoRoot });
   assert(compile.json?.phase?.parse === "ok", `AAPS compile check did not return a structured parse-ok report\n${formatAapsResult(compile)}`);
   assert(compile.ok && compile.json?.ok === true, `AAPS starter should compile cleanly after init\n${formatAapsResult(compile)}`);
+
+  const dryRun = await runAapsAction("dry-run", [], { cwd: tempRoot, packageDir: repoRoot });
+  const dryRunText = formatAapsResult(dryRun);
+  assert(dryRun.ok && dryRun.json?.dryRun === true, `AAPS dry-run failed\n${dryRunText}`);
+  assert(dryRunText.includes("promptOnly=1"), `AAPS dry-run summary should expose prompt-only steps\n${dryRunText}`);
+  assert(dryRunText.includes("did not execute an LLM/backend agent"), `AAPS dry-run should warn about prompt-only handoff\n${dryRunText}`);
+
+  const run = await runAapsAction("run", [], { cwd: tempRoot, packageDir: repoRoot });
+  const runText = formatAapsResult(run);
+  assert(run.ok && run.json?.dryRun === false, `AAPS run failed\n${runText}`);
+  assert(runText.includes("promptOnly=1"), `AAPS run summary should expose prompt-only steps\n${runText}`);
+  assert(
+    run.missingDeclaredOutputs?.includes("reports/aaps-plan.md") && runText.includes("declared output(s) not present after run"),
+    `AAPS run should report missing declared outputs for prompt-only starter workflows\n${runText}`
+  );
 } else {
   const validate = await runAapsAction("validate", [], { cwd: tempRoot, packageDir: repoRoot });
   assert(validate.ok === false && validate.error, "AAPS missing path should return a structured error");
@@ -57,7 +72,7 @@ console.log(
       tempRoot,
       realAaps: discovery.found,
       source: discovery.source || "",
-      checks: ["init", "files", "status", discovery.found ? "validate/parse/compile" : "missing-error"],
+      checks: ["init", "files", "status", discovery.found ? "validate/parse/compile/dry-run/run-warnings" : "missing-error"],
     },
     null,
     2

package/src/aaps-adapter.js

@@ -474,6 +474,65 @@ async function runDiscoveredAaps(discovery, cliArgs, { timeoutMs = DEFAULT_TIMEO
   }
 }
 
+function relativeIfInside(root, value = "") {
+  const text = String(value || "").trim();
+  if (!text) return "";
+  const resolved = path.isAbsolute(text) ? path.resolve(text) : path.resolve(root, text);
+  const relative = path.relative(root, resolved);
+  if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) return "";
+  return toProjectPath(relative);
+}
+
+async function annotateAapsRunResult(result, { action = "", projectDir = "" } = {}) {
+  if (!["run", "dry-run"].includes(action) || !result?.json || typeof result.json !== "object") return result;
+  const json = result.json;
+  const warnings = [];
+  const plan = json.plan || {};
+  const promptOnlySteps = Number(plan.promptOnlySteps || 0);
+  const executableSteps = Number(plan.executableSteps || 0);
+  if (promptOnlySteps > 0) {
+    warnings.push(
+      `workflow has ${promptOnlySteps} prompt-only step(s); AAPS recorded a handoff but did not execute an LLM/backend agent for those steps`
+    );
+  }
+  if (promptOnlySteps > 0 && executableSteps === 0) {
+    warnings.push("workflow has no executable steps; use AgInTiFlow to act on the prompt-only handoff or add executable AAPS actions");
+  }
+
+  const missingDeclaredOutputs = [];
+  if (action === "run" && !json.dryRun) {
+    const outputEntries = Array.isArray(json.outputs)
+      ? json.outputs
+      : Array.isArray(json.executionPlan?.outputs)
+        ? json.executionPlan.outputs
+        : [];
+    const runDir = String(json.runDir || "").trim();
+    const executionPlanPath = runDir ? path.join(runDir, "execution_plan.json") : "";
+    let executionPlan = null;
+    if (executionPlanPath && relativeIfInside(projectDir, executionPlanPath)) {
+      executionPlan = await readJsonIfExists(executionPlanPath);
+    }
+    const outputs = outputEntries.length ? outputEntries : Array.isArray(executionPlan?.outputs) ? executionPlan.outputs : [];
+    for (const output of outputs) {
+      const rawPath = typeof output === "string" ? output : output?.value || output?.path || "";
+      const rel = relativeIfInside(projectDir, rawPath);
+      if (!rel) continue;
+      if (!fsSync.existsSync(path.join(projectDir, rel))) missingDeclaredOutputs.push(rel);
+    }
+    if (missingDeclaredOutputs.length > 0) {
+      warnings.push(`declared output(s) not present after run: ${missingDeclaredOutputs.join(", ")}`);
+    }
+  }
+
+  return {
+    ...result,
+    warnings,
+    promptOnlySteps,
+    executableSteps,
+    missingDeclaredOutputs,
+  };
+}
+
 async function createAapsStarterProject({ cwd = process.cwd(), name = "" } = {}) {
   const projectDir = path.resolve(cwd || process.cwd());
   const projectName = String(name || path.basename(projectDir) || "AgInTiFlow AAPS Project").trim();
@@ -672,8 +731,9 @@ export async function runAapsAction(action = "status", rawArgs = [], { cwd = pro
 
   const built = buildAapsArgs(normalized, commandArgs, { cwd: projectDir });
   const result = await runDiscoveredAaps(discovery, built.cliArgs, { timeoutMs: built.timeoutMs });
+  const annotated = await annotateAapsRunResult(result, { action: built.action, projectDir });
   return {
-    ...result,
+    ...annotated,
     action: built.action,
     projectDir,
     source: discovery.source,
@@ -696,9 +756,19 @@ function summarizeJson(action, json) {
   }
   if (action === "check" || action === "plan" || action === "run" || action === "dry-run") {
     const ok = json.ok ?? json.ready ?? "";
-    const steps = json.plan?.steps?.length ?? json.steps?.length ?? "";
+    const steps = typeof json.plan?.steps === "number" ? json.plan.steps : (json.plan?.steps?.length ?? json.steps?.length ?? "");
+    const executable = json.plan?.executableSteps ?? "";
+    const promptOnly = json.plan?.promptOnlySteps ?? "";
     const runDir = json.runDir || json.runRoot || "";
-    return `ok=${ok} steps=${steps} runDir=${runDir}`;
+    return [
+      `ok=${ok}`,
+      steps !== "" ? `steps=${steps}` : "",
+      executable !== "" ? `executable=${executable}` : "",
+      promptOnly !== "" ? `promptOnly=${promptOnly}` : "",
+      runDir ? `runDir=${runDir}` : "",
+    ]
+      .filter(Boolean)
+      .join(" ");
   }
   return "";
 }
@@ -750,6 +820,7 @@ export function formatAapsResult(result = {}) {
     `AAPS ${result.action || "command"} ${result.ok ? "ok" : "failed"}`,
     result.command ? `command=${result.command}` : "",
     summary ? `summary=${summary}` : "",
+    result.warnings?.length ? `warnings\n${result.warnings.map((warning) => `- ${warning}`).join("\n")}` : "",
     result.stdout ? `stdout\n${result.stdout.trim()}` : "",
     result.stderr ? `stderr\n${result.stderr.trim()}` : "",
     result.error ? `error=${result.error}` : "",