@lazyingart/agintiflow 0.20.62 → 0.20.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.62",
+  "version": "0.20.64",
   "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-cli-chat.js

@@ -15,7 +15,7 @@ import {
   formatWorkspaceChange,
   stripMarkdown,
 } from "../src/interactive-cli.js";
-import { parseArgs } from "../src/cli.js";
+import { parseArgs, parseResumeCommandArgs, splitResumeCommandArgv } from "../src/cli.js";
 import { dockerPolicyTimeoutMs, dockerUserCommand } from "../src/docker-sandbox.js";
 import { formatBehaviorContractForPrompt } from "../src/behavior-contract.js";
 
@@ -286,6 +286,48 @@ try {
   if (scsAutoArgs.enableScs !== "auto" || scsAutoArgs.goal !== "fix this project") {
     throw new Error("--scs auto should consume auto and preserve the task");
   }
+  const resumeAfterOptions = parseResumeCommandArgs([
+    "web-agent-smoke",
+    "--provider",
+    "deepseek",
+    "--routing",
+    "smart",
+    "--sandbox-mode",
+    "host",
+    "--scout-count",
+    "3",
+  ]);
+  const resumeAfterParsed = parseArgs(resumeAfterOptions.optionArgv);
+  if (
+    resumeAfterOptions.sessionId !== "web-agent-smoke" ||
+    resumeAfterOptions.prompt ||
+    resumeAfterParsed.provider !== "deepseek" ||
+    resumeAfterParsed.routingMode !== "smart" ||
+    resumeAfterParsed.sandboxMode !== "host" ||
+    resumeAfterParsed.parallelScoutCount !== 3
+  ) {
+    throw new Error("resume subcommand options after the session id should remain options, not prompt text");
+  }
+  const resumePromptAfterDash = parseResumeCommandArgs(["web-agent-smoke", "--provider", "mock", "--", "--provider should be prompt"]);
+  if (
+    resumePromptAfterDash.sessionId !== "web-agent-smoke" ||
+    resumePromptAfterDash.prompt !== "--provider should be prompt" ||
+    parseArgs(resumePromptAfterDash.optionArgv).provider !== "mock"
+  ) {
+    throw new Error("resume subcommand should preserve explicit prompt text after --");
+  }
+  const leadingResume = splitResumeCommandArgv(["--provider", "mock", "--routing", "manual", "resume", "latest"]);
+  if (
+    !leadingResume ||
+    leadingResume.resumeArgv.join(" ") !== "latest" ||
+    parseArgs(leadingResume.leadingOptionArgv).provider !== "mock" ||
+    parseArgs(leadingResume.leadingOptionArgv).routingMode !== "manual"
+  ) {
+    throw new Error("leading global options before resume should still invoke the resume subcommand");
+  }
+  if (splitResumeCommandArgv(["--provider", "mock", "resume", "a normal task"]) !== null) {
+    throw new Error("leading global options should not turn an ordinary resume-themed prompt into the resume subcommand");
+  }
 
   await runCli(["init"], "");
   const instructions = await fs.readFile(path.join(tempRoot, "AGINTI.md"), "utf8");
@@ -420,6 +462,7 @@ try {
           "skills-command",
           "review-command",
           "scs-command-toggle",
+          "resume-command-options",
           "slash-prefix-autoselect",
           "slash-prefix-canonical-history",
           "instructions-chat-edit",

package/scripts/smoke-skills.js

@@ -72,6 +72,9 @@ assert(selectedIds("write README API docs and a tutorial").includes("docs-knowle
 assert(selectedIds("fix failing tests and add regression coverage").includes("qa-testing"), "QA prompt did not select qa-testing");
 const qaSkill = skills.find((skill) => skill.id === "qa-testing");
 assert(qaSkill?.body.includes("Do not invent staged bugs"), "QA skill does not guard against fake staged failures");
+const pythonSkill = skills.find((skill) => skill.id === "python");
+assert(pythonSkill?.body.includes("PEP 701 relaxed f-strings"), "Python skill must mention 3.12 f-string compatibility traps");
+assert(pythonSkill?.body.includes("only proves the active interpreter"), "Python skill must guard syntax-check overclaims");
 assert(selectedIds("write SQL migrations for sqlite schema").includes("database"), "database prompt did not select database");
 assert(selectedIds("debug Docker deployment logs and port config").includes("devops-deployment"), "devops prompt did not select devops-deployment");
 assert(selectedIds("review auth security and secrets handling").includes("security-review"), "security prompt did not select security-review");

package/skills/python/SKILL.md

@@ -21,4 +21,8 @@ tools:
 
 Inspect `pyproject.toml`, requirements, package layout, and tests. Prefer stdlib tests when dependency installs are unnecessary; otherwise use project-local venv/conda/uv or Docker.
 
+When reporting syntax, lint, test, or runtime results, always include the actual interpreter path/version and whether commands ran on the host or in Docker/venv. `py_compile` only proves the active interpreter accepted the files.
+
+For compatibility claims, avoid grep-only feature scans. Treat these as version-sensitive unless the target interpreter is tested: f-strings require Python 3.6+, `:=` requires 3.8+, builtin generic hints such as `list[int]` require 3.9+ unless postponed annotations are used, `match/case` and `X | Y` type unions require 3.10+, `except*`/`ExceptionGroup` require 3.11+, and PEP 701 relaxed f-strings (backslashes, comments, or previously invalid quoting/nesting inside f-string expressions) require 3.12+. If host compatibility matters and only Docker was tested, state that limitation instead of saying the code is safe on the host.
+
 For plots and artifacts, save files with clear names and send useful outputs to canvas.

package/src/cli.js

@@ -65,6 +65,205 @@ function readOptionalScsMode(argv, index) {
   return { mode: value, consumed: true };
 }
 
+const CLI_VALUE_OPTIONS = new Set([
+  "--port",
+  "--host",
+  "--language",
+  "--lang",
+  "-L",
+  "--start-url",
+  "--resume",
+  "--session-id",
+  "--provider",
+  "--model",
+  "--route-provider",
+  "--route-model",
+  "--main-provider",
+  "--main-model",
+  "--spare-provider",
+  "--spare-model",
+  "--spare-reasoning",
+  "--wrapper-model",
+  "--wrapper-reasoning",
+  "--aux-provider",
+  "--auxiliary-provider",
+  "--aux-model",
+  "--auxiliary-model",
+  "--routing",
+  "--cwd",
+  "--sandbox-mode",
+  "--package-install-policy",
+  "--max-steps",
+  "--scout-count",
+  "--wrapper",
+  "--preferred-wrapper",
+  "--profile",
+  "--task-profile",
+]);
+
+const CLI_FLAG_OPTIONS = new Set([
+  "--web",
+  "--chat",
+  "--interactive",
+  "--no-auto-update",
+  "--auto-update",
+  "--enable-scs",
+  "--disable-scs",
+  "--no-scs",
+  "--approve-package-installs",
+  "--latex",
+  "--image",
+  "--image-gen",
+  "--image-generation",
+  "--allow-shell",
+  "--no-shell",
+  "--allow-destructive",
+  "--trusted-host-shell",
+  "--allow-file-tools",
+  "--no-file-tools",
+  "--allow-auxiliary-tools",
+  "--allow-auxiliary",
+  "--no-auxiliary-tools",
+  "--no-auxiliary",
+  "--web-search",
+  "--no-web-search",
+  "--parallel-scouts",
+  "--no-parallel-scouts",
+  "--allow-wrappers",
+  "--docker-sandbox",
+  "--headless",
+  "--list-routes",
+  "--list-models",
+  "--models",
+  "--list-wrappers",
+  "--list-profiles",
+  "--list-skills",
+  "--sandbox-status",
+  "--sandbox-preflight",
+  "--scs",
+]);
+
+function collectCliOption(argv, index) {
+  const arg = argv[index];
+  if (arg === "--scs" || arg === "--enable-scs") {
+    const { consumed } = readOptionalScsMode(argv, index);
+    return { recognized: true, args: consumed ? [arg, argv[index + 1]] : [arg], nextIndex: index + (consumed ? 2 : 1) };
+  }
+  if (arg === "--language" || arg === "--lang" || arg === "-L") {
+    const first = readOption(argv, index);
+    const second = argv[index + 2] && !String(argv[index + 2]).startsWith("--") ? argv[index + 2] : "";
+    if (["cn", "zh"].includes(String(first || "").toLowerCase()) && ["s", "t"].includes(String(second || "").toLowerCase())) {
+      return { recognized: true, args: [arg, first, second], nextIndex: index + 3 };
+    }
+    return first
+      ? { recognized: true, args: [arg, first], nextIndex: index + 2 }
+      : { recognized: true, args: [arg], nextIndex: index + 1 };
+  }
+  if (CLI_VALUE_OPTIONS.has(arg)) {
+    const value = readOption(argv, index);
+    return value
+      ? { recognized: true, args: [arg, value], nextIndex: index + 2 }
+      : { recognized: true, args: [arg], nextIndex: index + 1 };
+  }
+  if (CLI_FLAG_OPTIONS.has(arg)) {
+    return { recognized: true, args: [arg], nextIndex: index + 1 };
+  }
+  return { recognized: false, args: [], nextIndex: index };
+}
+
+function looksLikeResumeSessionSelector(value) {
+  if (!value) return true;
+  const normalized = String(value);
+  return (
+    normalized === "latest" ||
+    normalized.startsWith("web-agent-") ||
+    normalized.startsWith("round") ||
+    normalized.startsWith("session-") ||
+    normalized.startsWith("aginti-")
+  );
+}
+
+function looksLikeResumeInvocation(resumeArgv = []) {
+  for (let index = 0; index < resumeArgv.length;) {
+    const arg = resumeArgv[index];
+    if (arg === "--" || looksLikeResumeSessionSelector(arg)) return looksLikeResumeSessionSelector(arg);
+    if (arg === "--all-sessions") {
+      index += 1;
+      continue;
+    }
+    const collected = collectCliOption(resumeArgv, index);
+    if (collected.recognized) {
+      index = collected.nextIndex;
+      continue;
+    }
+    return looksLikeResumeSessionSelector(arg);
+  }
+  return true;
+}
+
+export function splitResumeCommandArgv(argv = []) {
+  if (argv[0] === "resume") {
+    return { leadingOptionArgv: [], resumeArgv: argv.slice(1) };
+  }
+
+  const leadingOptionArgv = [];
+  let index = 0;
+  while (index < argv.length) {
+    if (argv[index] === "resume") {
+      const resumeArgv = argv.slice(index + 1);
+      return looksLikeResumeInvocation(resumeArgv) ? { leadingOptionArgv, resumeArgv } : null;
+    }
+    const collected = collectCliOption(argv, index);
+    if (!collected.recognized) return null;
+    leadingOptionArgv.push(...collected.args);
+    index = collected.nextIndex;
+  }
+  return null;
+}
+
+export function parseResumeCommandArgs(resumeArgv = [], leadingOptionArgv = []) {
+  const optionArgv = [...leadingOptionArgv];
+  const positional = [];
+  const promptParts = [];
+  let allSessions = false;
+  let promptMode = false;
+
+  for (let index = 0; index < resumeArgv.length;) {
+    const arg = resumeArgv[index];
+    if (promptMode) {
+      promptParts.push(arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--") {
+      promptMode = true;
+      index += 1;
+      continue;
+    }
+    if (arg === "--all-sessions") {
+      allSessions = true;
+      index += 1;
+      continue;
+    }
+    const collected = collectCliOption(resumeArgv, index);
+    if (collected.recognized) {
+      optionArgv.push(...collected.args);
+      index = collected.nextIndex;
+      continue;
+    }
+    if (positional.length === 0) positional.push(arg);
+    else promptParts.push(arg);
+    index += 1;
+  }
+
+  return {
+    allSessions,
+    optionArgv,
+    sessionId: positional[0] || "",
+    prompt: promptParts.join(" ").trim(),
+  };
+}
+
 export function parseArgs(argv) {
   const result = {
     goal: "",
@@ -1114,6 +1313,7 @@ export async function main(argv = process.argv.slice(2)) {
   const stripped = stripLeadingGlobalOptions(argv);
   const commandArgv = stripped.argv;
   const commandCwd = stripped.options.commandCwd || process.cwd();
+  const resumeCommand = splitResumeCommandArgv(commandArgv);
 
   if (commandArgv[0] === "aaps") {
     try {
@@ -1254,27 +1454,25 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
-  if (commandArgv[0] === "resume") {
-    const resumeArgv = commandArgv.slice(1);
-    const allSessions = resumeArgv.includes("--all-sessions");
-    const positional = resumeArgv.filter((arg) => arg !== "--all-sessions");
-    let sessionId = positional[0] || "";
-    const prompt = positional.slice(1).join(" ").trim();
+  if (resumeCommand) {
+    const resumeOptions = parseResumeCommandArgs(resumeCommand.resumeArgv, resumeCommand.leadingOptionArgv);
+    let sessionId = resumeOptions.sessionId;
+    const prompt = resumeOptions.prompt;
     try {
-      sessionId = await resolveResumeSessionId(sessionId, { allSessions });
+      sessionId = await resolveResumeSessionId(sessionId, { allSessions: resumeOptions.allSessions });
     } catch (error) {
       console.error(error instanceof Error ? error.message : String(error));
       process.exit(1);
     }
     if (!sessionId) return;
     if (!prompt) {
-      await startInteractiveCli(agentDefaults({ ...parseArgs([]), resume: sessionId, commandCwd }), {
+      await startInteractiveCli(agentDefaults({ ...parseArgs(resumeOptions.optionArgv), resume: sessionId, commandCwd }), {
         packageDir,
         packageVersion: packageJson.version,
       });
       return;
     }
-    const resumeArgs = agentDefaults({ ...parseArgs([prompt]), resume: sessionId, goal: prompt, commandCwd });
+    const resumeArgs = agentDefaults({ ...parseArgs([...resumeOptions.optionArgv, prompt]), resume: sessionId, goal: prompt, commandCwd });
     if (!(await ensureDeepSeekKeyForOneShot(resumeArgs))) process.exit(1);
     const config = loadConfig(resumeArgs, { packageDir });
     await runAgent(config);

package/src/task-profiles.js

@@ -143,7 +143,7 @@ export const TASK_PROFILES = {
     id: "python",
     label: "Python",
     prompt:
-      "Bias toward Python best practices without ignoring non-Python project context. Inspect pyproject/requirements, create scripts/packages/tests as files, prefer project-local venv/conda/uv or Docker for setup, and run focused smoke checks when shell is enabled. For syntax, lint, test, or runtime claims, capture the actual interpreter path/version and sandbox/host environment; never claim support for untested Python versions or host interpreters just because a Docker/venv check passed.",
+      "Bias toward Python best practices without ignoring non-Python project context. Inspect pyproject/requirements, create scripts/packages/tests as files, prefer project-local venv/conda/uv or Docker for setup, and run focused smoke checks when shell is enabled. For syntax, lint, test, or runtime claims, capture the actual interpreter path/version and sandbox/host environment; never claim support for untested Python versions or host interpreters just because a Docker/venv check passed. Remember Python syntax compatibility traps: f-strings require 3.6+, walrus 3.8+, builtin generics 3.9+, match/case and union type syntax 3.10+, except*/ExceptionGroup 3.11+, and relaxed PEP 701 f-string expressions with backslashes/comment/complex quoting require 3.12+.",
     tools: ["files", "shell", "sandbox"],
   },
   shell: {