@popoverai/dotrequirements 0.25.0 → 0.26.0

package/dist/commands/codebase-to-spec/pack.d.ts

@@ -7,8 +7,10 @@
  * - CTS-CLI-3: Pipeline refuses to spec a codebase that exceeds the working context budget
  * - CTS-PACK-1: Pack stage produces compressed and uncompressed views of the codebase
  * - CTS-PACK-2: Engineer can extend the ignore list per project
+ * - CTS-PACK-4: Pack surfaces when a newer CLI version is available
  * - CTS-OBSERVE-1: CLI emits structured progress as the pipeline runs
  */
+import { checkForNewerVersion } from "../../codebase-to-spec/version-check.js";
 export interface PackOptions {
     scope?: string;
     /**
@@ -28,6 +30,8 @@ export interface PackOptions {
     progress?: import("../../codebase-to-spec/progress.js").ProgressEmitter;
     /** Override the project root, mainly for tests. */
     projectRoot?: string;
+    /** Override the registry version check, mainly for tests. */
+    checkVersion?: typeof checkForNewerVersion;
 }
 export declare function packCommand(rawOptions?: PackOptions): Promise<void>;
 //# sourceMappingURL=pack.d.ts.map

package/dist/commands/codebase-to-spec/pack.js

@@ -7,6 +7,7 @@
  * - CTS-CLI-3: Pipeline refuses to spec a codebase that exceeds the working context budget
  * - CTS-PACK-1: Pack stage produces compressed and uncompressed views of the codebase
  * - CTS-PACK-2: Engineer can extend the ignore list per project
+ * - CTS-PACK-4: Pack surfaces when a newer CLI version is available
  * - CTS-OBSERVE-1: CLI emits structured progress as the pipeline runs
  */
 import { resolve } from "node:path";
@@ -15,11 +16,16 @@ import { clearCache, ensureCacheDir } from "../../codebase-to-spec/cache.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
 import { runPack } from "../../codebase-to-spec/pack.js";
 import { StdoutProgress } from "../../codebase-to-spec/progress.js";
+import { checkForNewerVersion } from "../../codebase-to-spec/version-check.js";
 import { findProjectRoot } from "../../utils/project-settings.js";
 export async function packCommand(rawOptions = {}) {
     const progress = rawOptions.progress ?? new StdoutProgress();
     const projectRoot = rawOptions.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
     const budgetTokens = rawOptions.budgetTokens ?? DEFAULT_BUDGET_TOKENS;
+    // Fail-soft staleness check (CTS-PACK-4), started now so the registry
+    // round-trip overlaps the pack work and adds no wall-clock on the happy
+    // path. Resolves to undefined on any failure or timeout.
+    const versionCheck = (rawOptions.checkVersion ?? checkForNewerVersion)();
     if (rawOptions.fresh) {
         progress.emit({
             stage: "pack",
@@ -54,6 +60,17 @@ export async function packCommand(rawOptions = {}) {
         message: `Packed ${packResult.fileCount} files → ${paths.overview} (compressed), ${paths.source} (uncompressed)`,
         data: { fileCount: packResult.fileCount },
     });
+    // Surface a stale install (CTS-PACK-4). Informational only: outputs and
+    // exit code are unaffected, and a failed check emits nothing.
+    const versionInfo = await versionCheck.catch(() => undefined);
+    if (versionInfo?.stale) {
+        progress.emit({
+            stage: "pack",
+            step: "stale-version",
+            message: `A newer dotrequirements CLI is available: ${versionInfo.latest} (running ${versionInfo.current}). Re-run skill-install to refresh.`,
+            data: { current: versionInfo.current, latest: versionInfo.latest },
+        });
+    }
     // Budget check (CTS-CLI-3)
     const measured = countTokensInFileExact(paths.overview);
     const budget = checkBudget(measured, budgetTokens);

package/dist/commands/init.js

@@ -353,8 +353,13 @@ async function inviteFlow(cwd, token) {
         console.log(`✓ Joined team "${inviteInfo.teamName}"`);
     }
     catch (err) {
+        // Production redacts ConvexError messages to "Server Error" but keeps
+        // error.data — check both, or this graceful path only works in dev
+        const data = err.data;
+        const dataMessage = typeof data?.message === "string" ? data.message : "";
         const errorMessage = err instanceof Error ? err.message : String(err);
-        if (errorMessage.includes("already a member")) {
+        if (dataMessage.includes("already a member") ||
+            errorMessage.includes("already a member")) {
             console.log(`Already a member of "${inviteInfo.teamName}"`);
         }
         else {

package/dist/commands/link-resolution.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Pure decision logic for `dotrequirements link`'s non-interactive mode
+ * (LINK-10/11/12). No I/O: the link command gathers state (teams, projects)
+ * and these functions decide what to do — use a project, create one, rename,
+ * or stop with a decision-needed result that carries everything an AI
+ * assistant needs to ask the user and retry with a deviation flag.
+ */
+export interface TeamOption {
+    teamId: string;
+    name: string;
+    tier: string;
+    tierName: string;
+    projectCount: number;
+    projectLimit: number;
+}
+export interface ProjectOption {
+    projectId: string;
+    projectName: string;
+    projectSlug: string | null;
+    isDefault: boolean;
+    hasUserContent: boolean;
+}
+export interface LinkFlags {
+    yes?: boolean;
+    team?: string;
+    connect?: string;
+    create?: boolean;
+    name?: string;
+    json?: boolean;
+}
+/**
+ * LINK-12.3: any deviation flag implies non-interactive mode.
+ */
+export declare function isNonInteractive(flags: LinkFlags): boolean;
+export declare function hasCapacity(team: TeamOption): boolean;
+/** A choice the user must make, with everything needed to ask and retry. */
+export interface DecisionNeeded {
+    kind: "decision";
+    decision: "team" | "project" | "capacity";
+    message: string;
+    options: Array<{
+        label: string;
+        /** Exact flag to pass on retry (LINK-11.4), when retryable via link */
+        retryFlag?: string;
+    }>;
+}
+export interface NoMatch {
+    kind: "no-match";
+    flag: "team" | "connect";
+    provided: string;
+    alternatives: string[];
+}
+export type TeamResolution = {
+    kind: "use";
+    team: TeamOption;
+} | DecisionNeeded | NoMatch;
+/**
+ * LINK-10.1, LINK-11.0, LINK-12.0, LINK-12.4
+ */
+export declare function resolveTeam(teams: TeamOption[], flags: LinkFlags): TeamResolution;
+export type ProjectResolution = {
+    kind: "connect";
+    project: ProjectOption;
+    rename: boolean;
+} | {
+    kind: "create";
+} | DecisionNeeded | NoMatch;
+/**
+ * LINK-10.2/10.3 (default-project rule), LINK-11.1/11.2 (decision menus),
+ * LINK-12.1/12.2/12.4 (deviation flags).
+ */
+export declare function resolveProject(projects: ProjectOption[], team: TeamOption, flags: LinkFlags): ProjectResolution;
+/**
+ * Prompt-free project naming for non-interactive mode (LINK-9.0): explicit
+ * flag, then package metadata, then directory name, then a fixed fallback —
+ * never a prompt.
+ */
+export declare function resolveProjectName(flags: LinkFlags, packageName: string | undefined, directoryName: string | undefined): string;
+//# sourceMappingURL=link-resolution.d.ts.map

package/dist/commands/link-resolution.js

@@ -0,0 +1,141 @@
+/**
+ * Pure decision logic for `dotrequirements link`'s non-interactive mode
+ * (LINK-10/11/12). No I/O: the link command gathers state (teams, projects)
+ * and these functions decide what to do — use a project, create one, rename,
+ * or stop with a decision-needed result that carries everything an AI
+ * assistant needs to ask the user and retry with a deviation flag.
+ */
+/**
+ * LINK-12.3: any deviation flag implies non-interactive mode.
+ */
+export function isNonInteractive(flags) {
+    return Boolean(flags.yes || flags.team || flags.connect || flags.create);
+}
+export function hasCapacity(team) {
+    return team.projectLimit === -1 || team.projectCount < team.projectLimit;
+}
+/**
+ * LINK-10.1, LINK-11.0, LINK-12.0, LINK-12.4
+ */
+export function resolveTeam(teams, flags) {
+    if (flags.team) {
+        const wanted = flags.team.toLowerCase();
+        const match = teams.find((t) => t.teamId === flags.team || t.name.toLowerCase() === wanted);
+        if (match)
+            return { kind: "use", team: match };
+        return {
+            kind: "no-match",
+            flag: "team",
+            provided: flags.team,
+            alternatives: teams.map((t) => `${t.name} (${t.teamId})`),
+        };
+    }
+    if (teams.length === 1) {
+        return { kind: "use", team: teams[0] };
+    }
+    return {
+        kind: "decision",
+        decision: "team",
+        message: "You belong to multiple teams — which should this project join?",
+        options: teams.map((t) => ({
+            label: `${t.name} (${t.tierName}, ${formatCapacity(t)})`,
+            retryFlag: `--team ${t.teamId}`,
+        })),
+    };
+}
+/**
+ * LINK-10.2/10.3 (default-project rule), LINK-11.1/11.2 (decision menus),
+ * LINK-12.1/12.2/12.4 (deviation flags).
+ */
+export function resolveProject(projects, team, flags) {
+    if (flags.connect) {
+        const match = projects.find((p) => p.projectSlug === flags.connect);
+        if (match)
+            return { kind: "connect", project: match, rename: false };
+        return {
+            kind: "no-match",
+            flag: "connect",
+            provided: flags.connect,
+            alternatives: projects
+                .filter((p) => p.projectSlug)
+                .map((p) => `${p.projectName} (${p.projectSlug})`),
+        };
+    }
+    if (flags.create) {
+        if (hasCapacity(team))
+            return { kind: "create" };
+        return atCapacityDecision(projects, team);
+    }
+    if (projects.length === 0) {
+        // A decision with a single possible answer is not a decision: create.
+        if (hasCapacity(team))
+            return { kind: "create" };
+        return atCapacityDecision(projects, team);
+    }
+    if (projects.length === 1 && projects[0].isDefault) {
+        // LINK-10.2: rename the untouched default project to match this repo;
+        // LINK-10.3: if the user has put content in it, connect without renaming
+        return {
+            kind: "connect",
+            project: projects[0],
+            rename: !projects[0].hasUserContent,
+        };
+    }
+    // LINK-11.1: existing projects the user chose to create — their call
+    return {
+        kind: "decision",
+        decision: "project",
+        message: "This team already has projects — connect to one, or create a new one?",
+        options: [
+            ...projects.map((p) => ({
+                label: `${p.projectName}${p.hasUserContent ? "" : " (empty)"}`,
+                retryFlag: p.projectSlug ? `--connect ${p.projectSlug}` : undefined,
+            })),
+            ...(hasCapacity(team)
+                ? [{ label: "Create a new project", retryFlag: "--create" }]
+                : []),
+        ],
+    };
+}
+/**
+ * LINK-11.2: creating is required (or requested) but the team is at its
+ * project limit. None of the remedies is a plain link retry flag.
+ */
+function atCapacityDecision(projects, team) {
+    return {
+        kind: "decision",
+        decision: "capacity",
+        message: `Team "${team.name}" is at its ${team.tierName} project limit (${formatCapacity(team)}).`,
+        options: [
+            ...projects
+                .filter((p) => p.projectSlug)
+                .map((p) => ({
+                label: `Connect to existing project ${p.projectName}`,
+                retryFlag: `--connect ${p.projectSlug}`,
+            })),
+            { label: "Delete a project you no longer need (in the web app)" },
+            { label: "Upgrade the team for more projects" },
+        ],
+    };
+}
+function formatCapacity(team) {
+    return team.projectLimit === -1
+        ? `${team.projectCount}/unlimited projects`
+        : `${team.projectCount}/${team.projectLimit} projects`;
+}
+/**
+ * Prompt-free project naming for non-interactive mode (LINK-9.0): explicit
+ * flag, then package metadata, then directory name, then a fixed fallback —
+ * never a prompt.
+ */
+export function resolveProjectName(flags, packageName, directoryName) {
+    if (flags.name)
+        return flags.name;
+    if (packageName)
+        return packageName;
+    if (directoryName && directoryName !== "/" && directoryName !== ".") {
+        return directoryName;
+    }
+    return "my-project";
+}
+//# sourceMappingURL=link-resolution.js.map

package/dist/commands/link.d.ts

@@ -1,14 +1,24 @@
+import { type LinkFlags } from "./link-resolution.js";
+export interface LinkCommandOptions extends LinkFlags {
+}
 /**
- * Link command - connect or reconnect local project to cloud.
+ * Link command - connect or reconnect local project to cloud, creating the
+ * cloud project when needed. Link owns the "upgrade local to cloud"
+ * transition.
  *
  * Requirements:
  * - LINK-1: Requires existing .requirements/ folder
  * - LINK-2: Offers refresh when credentials exist
  * - LINK-3: Uses inline OAuth (no persistent tokens)
- * - LINK-4, LINK-5: Team and project selection
+ * - LINK-4, LINK-5: Team and project selection (including the create option)
  * - LINK-6: Saves credentials to project-settings.json
- * - LINK-7: Optionally pulls requirements
+ * - LINK-7: Optionally pulls requirements (interactive only)
  * - LINK-8: Handles network errors gracefully
+ * - LINK-9: Creates the cloud project when chosen
+ * - LINK-10/11/12: Non-interactive mode for AI-driven setup
+ * - LINK-13: Non-interactive success includes share artifacts (team-invite
+ *   URL + read-only pull command) so one "yes" puts the spec in front of
+ *   the team
  */
-export declare function linkCommand(): Promise<void>;
+export declare function linkCommand(options?: LinkCommandOptions): Promise<void>;
 //# sourceMappingURL=link.d.ts.map