@askthew/mcp-plugin 0.4.0 → 0.4.2

package/dist/install.d.ts

@@ -7,12 +7,21 @@ interface HostConfigInput {
     clientId?: string;
     clientLabel?: string;
     free?: boolean;
+    email?: string;
+    cwd?: string;
 }
 interface InstallHostConfigInput extends HostConfigInput {
     dryRun?: boolean;
     homeDirectory?: string;
     cwd?: string;
 }
+interface UninstallHostConfigInput {
+    hostType: SupportedHostType;
+    serverName?: string;
+    dryRun?: boolean;
+    homeDirectory?: string;
+    cwd?: string;
+}
 export declare function resolveSettingsPath(input: {
     hostType: SupportedHostType;
     homeDirectory?: string;
@@ -21,15 +30,23 @@ export declare function createServerEntry(input: HostConfigInput): {
     command: string;
     args: string[];
     env: {
+        ASKTHEW_SERVICE_NAME?: string | undefined;
+        ASKTHEW_APP_PATH?: string | undefined;
+        ASKTHEW_REPO_ROOT?: string | undefined;
         ASKTHEW_HOST_TYPE: SupportedHostType;
         ASKTHEW_SERVER_NAME: string;
+        ASKTHEW_REPO_NAME: string;
         ASKTHEW_CLIENT_LABEL?: string | undefined;
         ASKTHEW_CLIENT_ID?: string | undefined;
         ASKTHEW_FREE_MODE: string;
         ASKTHEW_API_URL: string;
     } | {
+        ASKTHEW_SERVICE_NAME?: string | undefined;
+        ASKTHEW_APP_PATH?: string | undefined;
+        ASKTHEW_REPO_ROOT?: string | undefined;
         ASKTHEW_HOST_TYPE: SupportedHostType;
         ASKTHEW_SERVER_NAME: string;
+        ASKTHEW_REPO_NAME: string;
         ASKTHEW_CLIENT_LABEL?: string | undefined;
         ASKTHEW_CLIENT_ID?: string | undefined;
         ASKTHEW_INSTALL_TOKEN: string;
@@ -48,15 +65,23 @@ export declare function createHostConfigSnippet(input: HostConfigInput): {
                 command: string;
                 args: string[];
                 env: {
+                    ASKTHEW_SERVICE_NAME?: string | undefined;
+                    ASKTHEW_APP_PATH?: string | undefined;
+                    ASKTHEW_REPO_ROOT?: string | undefined;
                     ASKTHEW_HOST_TYPE: SupportedHostType;
                     ASKTHEW_SERVER_NAME: string;
+                    ASKTHEW_REPO_NAME: string;
                     ASKTHEW_CLIENT_LABEL?: string | undefined;
                     ASKTHEW_CLIENT_ID?: string | undefined;
                     ASKTHEW_FREE_MODE: string;
                     ASKTHEW_API_URL: string;
                 } | {
+                    ASKTHEW_SERVICE_NAME?: string | undefined;
+                    ASKTHEW_APP_PATH?: string | undefined;
+                    ASKTHEW_REPO_ROOT?: string | undefined;
                     ASKTHEW_HOST_TYPE: SupportedHostType;
                     ASKTHEW_SERVER_NAME: string;
+                    ASKTHEW_REPO_NAME: string;
                     ASKTHEW_CLIENT_LABEL?: string | undefined;
                     ASKTHEW_CLIENT_ID?: string | undefined;
                     ASKTHEW_INSTALL_TOKEN: string;
@@ -82,6 +107,12 @@ export declare function installHostConfig(input: InstallHostConfigInput): {
     wroteFile: boolean;
     nextStep: string;
 };
+export declare function uninstallHostConfig(input: UninstallHostConfigInput): {
+    settingsPath: string;
+    json: string;
+    removedServerName: string;
+    wroteFile: boolean;
+};
 export declare function sendInstallHeartbeat(input: HostConfigInput & {
     cwd?: string;
     fetchImpl?: typeof fetch;
@@ -92,7 +123,16 @@ export declare function installBehaviorInstructions(input: {
     dryRun?: boolean;
 }): {
     path: string;
+    paths: string[];
     wroteFile: boolean;
     content: string;
 };
+export declare function uninstallBehaviorInstructions(input: {
+    hostType: SupportedHostType;
+    cwd?: string;
+    dryRun?: boolean;
+}): {
+    paths: string[];
+    wroteFile: boolean;
+};
 export {};

package/dist/install.js

@@ -18,6 +18,7 @@ export function resolveSettingsPath(input) {
     return path.join(homeDirectory, ".claude.json");
 }
 export function createServerEntry(input) {
+    const scope = resolvePluginScope(input.cwd ?? process.cwd());
     return {
         command: "npx",
         args: ["-y", "--prefer-online", "@askthew/mcp-plugin@latest"],
@@ -28,6 +29,10 @@ export function createServerEntry(input) {
             ...(input.clientLabel ? { ASKTHEW_CLIENT_LABEL: input.clientLabel } : {}),
             ASKTHEW_HOST_TYPE: input.hostType,
             ASKTHEW_SERVER_NAME: input.serverName,
+            ASKTHEW_REPO_NAME: scope.repoName,
+            ...(scope.repoRoot ? { ASKTHEW_REPO_ROOT: scope.repoRoot } : {}),
+            ...(scope.appPath ? { ASKTHEW_APP_PATH: scope.appPath } : {}),
+            ...(scope.serviceName ? { ASKTHEW_SERVICE_NAME: scope.serviceName } : {}),
         },
     };
 }
@@ -139,6 +144,9 @@ export function formatInstallCommand(input) {
     ];
     if (input.free) {
         parts.push("--free");
+        if (input.email) {
+            parts.push("--email", JSON.stringify(input.email));
+        }
     }
     else {
         parts.splice(7, 0, "--token", JSON.stringify(input.token ?? ""));
@@ -179,6 +187,8 @@ export function installHostConfig(input) {
         serverName: input.serverName,
         clientId: input.clientId,
         clientLabel: input.clientLabel,
+        free: input.free,
+        cwd: input.cwd,
     };
     const json = input.hostType === "codex"
         ? mergeCodexSettings({
@@ -202,6 +212,65 @@ export function installHostConfig(input) {
         nextStep: verificationNextStep(input.hostType),
     };
 }
+export function uninstallHostConfig(input) {
+    const settingsPath = resolveSettingsPath({
+        hostType: input.hostType,
+        homeDirectory: input.homeDirectory,
+    });
+    const serverName = input.serverName?.trim() || "askthew";
+    let json = "";
+    if (fs.existsSync(settingsPath)) {
+        const raw = fs.readFileSync(settingsPath, "utf8");
+        if (input.hostType === "codex") {
+            json = removeCodexTomlServer(raw, serverName);
+            if (serverName !== "askthew") {
+                json = removeCodexTomlServer(json, "askthew");
+            }
+            json = json ? `${json}\n` : "";
+        }
+        else {
+            const parsed = raw.trim() ? JSON.parse(raw) : {};
+            if (input.hostType === "claude_code") {
+                const cwd = path.resolve(input.cwd ?? process.cwd());
+                const existingProjects = isRecord(parsed.projects) ? parsed.projects : {};
+                const existingProject = isRecord(existingProjects[cwd]) ? existingProjects[cwd] : {};
+                const existingMcpServers = isRecord(existingProject.mcpServers) ? existingProject.mcpServers : {};
+                const nextServers = { ...existingMcpServers };
+                delete nextServers[serverName];
+                if (serverName !== "askthew")
+                    delete nextServers.askthew;
+                json = JSON.stringify({
+                    ...parsed,
+                    projects: {
+                        ...existingProjects,
+                        [cwd]: {
+                            ...existingProject,
+                            mcpServers: nextServers,
+                        },
+                    },
+                }, null, 2);
+            }
+            else {
+                const existingMcpServers = isRecord(parsed.mcpServers) ? parsed.mcpServers : {};
+                const nextServers = { ...existingMcpServers };
+                delete nextServers[serverName];
+                if (serverName !== "askthew")
+                    delete nextServers.askthew;
+                json = JSON.stringify({ ...parsed, mcpServers: nextServers }, null, 2);
+            }
+            json = `${json}\n`;
+        }
+        if (!input.dryRun) {
+            fs.writeFileSync(settingsPath, json, "utf8");
+        }
+    }
+    return {
+        settingsPath,
+        json,
+        removedServerName: serverName,
+        wroteFile: !input.dryRun,
+    };
+}
 export async function sendInstallHeartbeat(input) {
     const fetcher = input.fetchImpl ?? fetch;
     const scope = resolvePluginScope(input.cwd ?? process.cwd());
@@ -225,8 +294,41 @@ export async function sendInstallHeartbeat(input) {
     });
     return response.ok;
 }
-function behaviorInstructions(hostType) {
+function detectStackGuidance(cwd) {
+    const packagePath = path.join(cwd, "package.json");
+    if (!fs.existsSync(packagePath)) {
+        return [];
+    }
+    let manifest = {};
+    try {
+        manifest = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+    }
+    catch {
+        return [];
+    }
+    const deps = {
+        ...(manifest.dependencies ?? {}),
+        ...(manifest.devDependencies ?? {}),
+    };
+    const names = new Set(Object.keys(deps));
+    const guidance = [];
+    if (names.has("next")) {
+        guidance.push("- Next.js detected: after changing route handlers, server actions, middleware, or cache behavior, capture `verification_result` with the command/result.");
+    }
+    if (names.has("express") || names.has("@types/express")) {
+        guidance.push("- Express detected: after changing middleware, request validation, or response envelopes, capture `verification_result` with the command/result.");
+    }
+    if (names.has("vite") || names.has("@vitejs/plugin-react")) {
+        guidance.push("- Vite detected: after changing client entrypoints, env handling, or build config, capture `verification_result` with the command/result.");
+    }
+    if (names.has("openai") || names.has("@openai/agents") || names.has("@ai-sdk/openai")) {
+        guidance.push("- OpenAI SDK detected: after editing prompts, model calls, streaming/SSE, or schema-validated responses, capture `direction_change` for prompt choices and `verification_result` for checked outputs.");
+    }
+    return guidance.slice(0, 4);
+}
+function behaviorInstructions(hostType, cwd = process.cwd()) {
     const hostLabel = hostType === "claude_code" ? "Claude Code" : hostType === "cursor" ? "Cursor" : "Codex";
+    const stackGuidance = detectStackGuidance(cwd);
     return [
         ASKTHEW_INSTRUCTIONS_START,
         "",
@@ -241,10 +343,10 @@ function behaviorInstructions(hostType) {
         "",
         "Send an update:",
         "- after the user accepts or rejects product, architecture, or implementation direction",
-        "- after meaningful implementation changes",
+        "- before using tools that write files, after meaningful implementation changes",
         "- after tests, builds, lint, or other verification",
-        "- every 8-12 turns in long sessions",
         "- at the final summary",
+        ...(stackGuidance.length > 0 ? ["", "Stack-specific nudges:", ...stackGuidance] : []),
         "",
         "Keep updates compact: short summary, minimal evidence excerpts, files touched, commands run, and useful metadata. Do not send full transcripts. Redact obvious secrets before sending.",
         "",
@@ -252,14 +354,14 @@ function behaviorInstructions(hostType) {
         "",
     ].join("\n");
 }
-function cursorBehaviorInstructions() {
+function cursorBehaviorInstructions(cwd = process.cwd()) {
     return [
         "---",
         "description: Ask The W Plugin capture rules",
         "alwaysApply: true",
         "---",
         "",
-        behaviorInstructions("cursor"),
+        behaviorInstructions("cursor", cwd),
     ].join("\n");
 }
 function upsertMarkedBlock(existing, block) {
@@ -273,21 +375,56 @@ function upsertMarkedBlock(existing, block) {
 }
 export function installBehaviorInstructions(input) {
     const cwd = path.resolve(input.cwd ?? process.cwd());
-    const instructionsPath = input.hostType === "claude_code"
-        ? path.join(cwd, "CLAUDE.md")
-        : input.hostType === "cursor"
-            ? path.join(cwd, ".cursor", "rules", "askthew.mdc")
-            : path.join(cwd, "AGENTS.md");
-    const block = input.hostType === "cursor" ? cursorBehaviorInstructions() : behaviorInstructions(input.hostType);
-    const existing = fs.existsSync(instructionsPath) ? fs.readFileSync(instructionsPath, "utf8") : "";
-    const next = input.hostType === "cursor" ? block : upsertMarkedBlock(existing, block);
-    if (!input.dryRun) {
-        fs.mkdirSync(path.dirname(instructionsPath), { recursive: true });
-        fs.writeFileSync(instructionsPath, next, "utf8");
+    const markdownBlock = behaviorInstructions(input.hostType, cwd);
+    const markdownTargets = [path.join(cwd, "CLAUDE.md"), path.join(cwd, "AGENTS.md")];
+    const writtenPaths = [];
+    let primaryPath = input.hostType === "claude_code" ? markdownTargets[0] : markdownTargets[1];
+    for (const instructionsPath of markdownTargets) {
+        const existing = fs.existsSync(instructionsPath) ? fs.readFileSync(instructionsPath, "utf8") : "";
+        const next = upsertMarkedBlock(existing, markdownBlock);
+        if (!input.dryRun) {
+            fs.mkdirSync(path.dirname(instructionsPath), { recursive: true });
+            fs.writeFileSync(instructionsPath, next, "utf8");
+        }
+        writtenPaths.push(instructionsPath);
+    }
+    if (input.hostType === "cursor") {
+        const cursorPath = path.join(cwd, ".cursor", "rules", "askthew.mdc");
+        if (!input.dryRun) {
+            fs.mkdirSync(path.dirname(cursorPath), { recursive: true });
+            fs.writeFileSync(cursorPath, cursorBehaviorInstructions(cwd), "utf8");
+        }
+        writtenPaths.push(cursorPath);
+        primaryPath = cursorPath;
+    }
+    return {
+        path: primaryPath,
+        paths: writtenPaths,
+        wroteFile: !input.dryRun,
+        content: markdownBlock,
+    };
+}
+export function uninstallBehaviorInstructions(input) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    const markdownTargets = [path.join(cwd, "CLAUDE.md"), path.join(cwd, "AGENTS.md")];
+    const touchedPaths = [];
+    for (const instructionsPath of markdownTargets) {
+        if (!fs.existsSync(instructionsPath))
+            continue;
+        const existing = fs.readFileSync(instructionsPath, "utf8");
+        const next = existing.replace(new RegExp(`\\n?${ASKTHEW_INSTRUCTIONS_START}[\\s\\S]*?${ASKTHEW_INSTRUCTIONS_END}\\n?`, "g"), "\n").trimEnd() + "\n";
+        if (!input.dryRun)
+            fs.writeFileSync(instructionsPath, next, "utf8");
+        touchedPaths.push(instructionsPath);
+    }
+    const cursorPath = path.join(cwd, ".cursor", "rules", "askthew.mdc");
+    if (input.hostType === "cursor" && fs.existsSync(cursorPath)) {
+        if (!input.dryRun)
+            fs.rmSync(cursorPath, { force: true });
+        touchedPaths.push(cursorPath);
     }
     return {
-        path: instructionsPath,
+        paths: touchedPaths,
         wroteFile: !input.dryRun,
-        content: next,
     };
 }

package/dist/install.test.js

@@ -3,8 +3,10 @@ import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { formatInstallCommand, installBehaviorInstructions, installHostConfig, mergeHostSettings, resolveSettingsPath, sendInstallHeartbeat, verificationNextStep, } from "./install.js";
+import { formatInstallCommand, installBehaviorInstructions, installHostConfig, mergeHostSettings, resolveSettingsPath, sendInstallHeartbeat, uninstallBehaviorInstructions, uninstallHostConfig, verificationNextStep, } from "./install.js";
 test("mergeHostSettings preserves unrelated MCP servers and replaces askthew", () => {
+    const tempProject = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-merge-project-"));
+    fs.writeFileSync(path.join(tempProject, "package.json"), "{}", "utf8");
     const merged = mergeHostSettings({
         existingSettings: {
             theme: "dark",
@@ -21,6 +23,7 @@ test("mergeHostSettings preserves unrelated MCP servers and replaces askthew", (
         token: "token-123",
         apiUrl: "https://askthew.example.com",
         serverName: "askthew_workspace_a",
+        cwd: tempProject,
     });
     assert.deepEqual(merged.theme, "dark");
     assert.deepEqual(Object.keys(merged.mcpServers ?? {}).sort(), ["askthew_workspace_a", "github"]);
@@ -32,8 +35,11 @@ test("mergeHostSettings preserves unrelated MCP servers and replaces askthew", (
             ASKTHEW_API_URL: "https://askthew.example.com",
             ASKTHEW_HOST_TYPE: "codex",
             ASKTHEW_SERVER_NAME: "askthew_workspace_a",
+            ASKTHEW_REPO_NAME: path.basename(tempProject),
+            ASKTHEW_REPO_ROOT: tempProject,
         },
     });
+    fs.rmSync(tempProject, { recursive: true, force: true });
 });
 test("installHostConfig writes Claude Code local MCP settings and stays idempotent", () => {
     const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-mcp-install-"));
@@ -204,21 +210,26 @@ test("sendInstallHeartbeat pings Ask The W after config install", async () => {
 });
 test("installBehaviorInstructions adds persistent Codex tracking rules without clobbering existing instructions", () => {
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-agent-instructions-"));
+    const claudePath = path.join(tempRoot, "CLAUDE.md");
     const agentsPath = path.join(tempRoot, "AGENTS.md");
     fs.writeFileSync(agentsPath, "# Existing instructions\n\nKeep this section.\n", "utf8");
     const result = installBehaviorInstructions({
         hostType: "codex",
         cwd: tempRoot,
     });
+    const claudeContents = fs.readFileSync(claudePath, "utf8");
     const contents = fs.readFileSync(agentsPath, "utf8");
     assert.equal(result.path, agentsPath);
+    assert.deepEqual(result.paths, [claudePath, agentsPath]);
+    assert.match(claudeContents, /Ask The W Plugin/);
+    assert.match(claudeContents, /At the start of every new Codex session in this repo/);
     assert.match(contents, /# Existing instructions/);
     assert.match(contents, /Ask The W Plugin/);
     assert.match(contents, /capture_session_signal/);
     assert.match(contents, /At the start of every new Codex session in this repo/);
     assert.match(contents, /before plan mode, exploration, or any normal reply/);
     assert.match(contents, /metadata\.recovered_missed_startup=true/);
-    assert.match(contents, /every 8-12 turns/);
+    assert.match(contents, /before using tools that write files/);
     fs.rmSync(tempRoot, { recursive: true, force: true });
 });
 test("installBehaviorInstructions creates Cursor rule file", () => {
@@ -235,3 +246,52 @@ test("installBehaviorInstructions creates Cursor rule file", () => {
     assert.match(fs.readFileSync(result.path, "utf8"), /metadata\.recovered_missed_startup=true/);
     fs.rmSync(tempRoot, { recursive: true, force: true });
 });
+test("installBehaviorInstructions adds stack-specific verification nudges", () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-stack-rules-"));
+    fs.writeFileSync(path.join(tempRoot, "package.json"), JSON.stringify({
+        dependencies: {
+            next: "^15.0.0",
+            openai: "^5.0.0",
+            vite: "^6.0.0",
+        },
+    }), "utf8");
+    const result = installBehaviorInstructions({
+        hostType: "codex",
+        cwd: tempRoot,
+        dryRun: true,
+    });
+    assert.match(result.content, /Next\.js detected/);
+    assert.match(result.content, /OpenAI SDK detected/);
+    assert.match(result.content, /Vite detected/);
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+test("uninstall removes host config and Ask The W agent instruction blocks", () => {
+    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-uninstall-home-"));
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-uninstall-project-"));
+    installHostConfig({
+        hostType: "codex",
+        token: "token-uninstall",
+        apiUrl: "https://askthew.example.com",
+        serverName: "askthew",
+        homeDirectory: tempHome,
+    });
+    installBehaviorInstructions({
+        hostType: "codex",
+        cwd: tempRoot,
+    });
+    const removed = uninstallHostConfig({
+        hostType: "codex",
+        serverName: "askthew",
+        homeDirectory: tempHome,
+    });
+    const instructions = uninstallBehaviorInstructions({
+        hostType: "codex",
+        cwd: tempRoot,
+    });
+    assert.doesNotMatch(fs.readFileSync(removed.settingsPath, "utf8"), /askthew/);
+    assert.equal(instructions.paths.length, 2);
+    assert.doesNotMatch(fs.readFileSync(path.join(tempRoot, "AGENTS.md"), "utf8"), /ASKTHEW_PLUGIN_INSTRUCTIONS_START/);
+    assert.doesNotMatch(fs.readFileSync(path.join(tempRoot, "CLAUDE.md"), "utf8"), /ASKTHEW_PLUGIN_INSTRUCTIONS_START/);
+    fs.rmSync(tempHome, { recursive: true, force: true });
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});

package/dist/lib/auth-pending.d.ts

@@ -0,0 +1,23 @@
+type CliConfig = {
+    pendingAuth?: {
+        email: string;
+        requestId: string;
+        expiresAt: string;
+        telemetryOptOut?: boolean;
+    };
+};
+export declare function savePendingAuth(input: NonNullable<CliConfig["pendingAuth"]>, env?: NodeJS.ProcessEnv): void;
+export declare function clearPendingAuth(env?: NodeJS.ProcessEnv): void;
+export declare function pendingAuthForEmail(email: string, env?: NodeJS.ProcessEnv): {
+    email: string;
+    requestId: string;
+    expiresAt: string;
+    telemetryOptOut?: boolean;
+} | null;
+export declare function pendingAuth(env?: NodeJS.ProcessEnv): {
+    email: string;
+    requestId: string;
+    expiresAt: string;
+    telemetryOptOut?: boolean;
+} | null;
+export {};

package/dist/lib/auth-pending.js

@@ -0,0 +1,36 @@
+import { configPath, readJsonFile, writePrivateJson } from "./paths.js";
+function loadCliConfig(env = process.env) {
+    return readJsonFile(configPath(env)) ?? {};
+}
+export function savePendingAuth(input, env = process.env) {
+    const config = loadCliConfig(env);
+    writePrivateJson(configPath(env), {
+        ...config,
+        pendingAuth: input,
+    });
+}
+export function clearPendingAuth(env = process.env) {
+    const config = loadCliConfig(env);
+    if (!config.pendingAuth)
+        return;
+    const { pendingAuth: _pendingAuth, ...next } = config;
+    writePrivateJson(configPath(env), next);
+}
+export function pendingAuthForEmail(email, env = process.env) {
+    const pending = pendingAuth(env);
+    if (!pending || pending.email.toLowerCase() !== email.toLowerCase()) {
+        return null;
+    }
+    return pending;
+}
+export function pendingAuth(env = process.env) {
+    const pending = loadCliConfig(env).pendingAuth;
+    if (!pending) {
+        return null;
+    }
+    if (Number.isFinite(Date.parse(pending.expiresAt)) && Date.parse(pending.expiresAt) <= Date.now()) {
+        clearPendingAuth(env);
+        return null;
+    }
+    return pending;
+}

package/dist/lib/cli-actions.d.ts

@@ -0,0 +1,28 @@
+import type { LocalStore } from "./local-store.js";
+export declare function localScopeKey(cwd?: string): string;
+export declare function installPreCommitHook(input?: {
+    cwd?: string;
+}): string;
+export declare function stagedFiles(input?: {
+    cwd?: string;
+}): string[];
+export declare function preCommitDecisionGap(input: {
+    store: LocalStore;
+    stagedFiles: string[];
+    now?: Date;
+    scopeKey?: string | null;
+}): {
+    missing: boolean;
+    matchedSignals: number[];
+};
+export declare function isoWeek(date: Date): string;
+export declare function buildWeeklyDigest(input: {
+    store: LocalStore;
+    now?: Date;
+    scopeKey?: string | null;
+}): string;
+export declare function writeWeeklyDigest(input: {
+    store: LocalStore;
+    now?: Date;
+    outputDir?: string;
+}): string;

package/dist/lib/cli-actions.js

@@ -0,0 +1,104 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { configPath, readJsonFile } from "./paths.js";
+import { resolvePluginScope } from "../scope.js";
+function readConfig() {
+    return readJsonFile(configPath()) ?? {};
+}
+export function localScopeKey(cwd = process.cwd()) {
+    const scope = resolvePluginScope(cwd);
+    return [scope.repoRoot || scope.repoName || cwd, scope.appPath ?? "", scope.serviceName ?? ""]
+        .filter(Boolean)
+        .join("::")
+        .replace(/\s+/g, " ")
+        .slice(0, 500);
+}
+export function installPreCommitHook(input = {}) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    const gitDir = execFileSync("git", ["rev-parse", "--git-dir"], { cwd, encoding: "utf8" }).trim();
+    const hookPath = path.resolve(cwd, gitDir, "hooks", "pre-commit");
+    const hook = [
+        "#!/bin/sh",
+        "# Ask The W pre-commit decision prompt",
+        "npx -y --prefer-online @askthew/mcp-plugin@latest hook-check --pre-commit",
+        "",
+    ].join("\n");
+    fs.mkdirSync(path.dirname(hookPath), { recursive: true });
+    fs.writeFileSync(hookPath, hook, { encoding: "utf8", mode: 0o755 });
+    fs.chmodSync(hookPath, 0o755);
+    return hookPath;
+}
+export function stagedFiles(input = {}) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    return execFileSync("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf8" })
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export function preCommitDecisionGap(input) {
+    const staged = new Set(input.stagedFiles);
+    if (staged.size === 0) {
+        return { missing: false, matchedSignals: [] };
+    }
+    const nowMs = (input.now ?? new Date()).getTime();
+    const scopeKey = input.scopeKey;
+    const recentImplementationSignals = input.store
+        .listSignals({ scopeKey, limit: 100000 })
+        .filter((signal) => signal.kind === "implementation_update")
+        .filter((signal) => nowMs - new Date(signal.capturedAt).getTime() <= 14 * 24 * 60 * 60 * 1000)
+        .filter((signal) => signal.filesTouched.some((file) => staged.has(file)));
+    if (recentImplementationSignals.length === 0) {
+        return { missing: false, matchedSignals: [] };
+    }
+    const matchedSignalIds = new Set(recentImplementationSignals.map((signal) => signal.id));
+    const linkedDecision = input.store.listDecisions({ scopeKey, limit: 100000 }).some((decision) => {
+        if (decision.sourceSignalIds.some((id) => matchedSignalIds.has(id)))
+            return true;
+        return decision.files.some((file) => staged.has(file));
+    });
+    return {
+        missing: !linkedDecision,
+        matchedSignals: Array.from(matchedSignalIds),
+    };
+}
+export function isoWeek(date) {
+    const utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const day = utcDate.getUTCDay() || 7;
+    utcDate.setUTCDate(utcDate.getUTCDate() + 4 - day);
+    const yearStart = new Date(Date.UTC(utcDate.getUTCFullYear(), 0, 1));
+    const week = Math.ceil(((utcDate.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+    return `${utcDate.getUTCFullYear()}-${String(week).padStart(2, "0")}`;
+}
+export function buildWeeklyDigest(input) {
+    const now = input.now ?? new Date();
+    const since = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const scopeKey = input.scopeKey;
+    const decisions = input.store.listDecisions({ scopeKey, since, limit: 100000 });
+    const signals = input.store.listSignals({ scopeKey, limit: 100000 }).filter((signal) => signal.capturedAt >= since);
+    const lines = [
+        `# Ask The W Weekly Decision Digest ${isoWeek(now)}`,
+        "",
+        `Signals captured: ${signals.length}`,
+        `Decisions captured: ${decisions.length}`,
+        "",
+        "## Decisions",
+        ...(decisions.length
+            ? decisions.map((decision) => `- ${decision.headline} (${decision.status})${decision.why ? ` - ${decision.why}` : ""}`)
+            : ["- No decisions captured this week."]),
+    ];
+    if (readConfig().digest?.footer !== false) {
+        lines.push("", "_Captured by Ask The W._");
+    }
+    return lines.join("\n");
+}
+export function writeWeeklyDigest(input) {
+    const now = input.now ?? new Date();
+    const configuredOutputDir = input.outputDir ?? process.env.ASKTHEW_DIGEST_DIR?.trim();
+    const outputDir = configuredOutputDir || path.join(os.homedir(), "Documents");
+    fs.mkdirSync(outputDir, { recursive: true });
+    const filePath = path.join(outputDir, `askthew-digest-${isoWeek(now)}.md`);
+    fs.writeFileSync(filePath, `${buildWeeklyDigest({ store: input.store, now, scopeKey: localScopeKey() })}\n`, "utf8");
+    return filePath;
+}

package/dist/lib/free-install-registration.d.ts

@@ -0,0 +1,27 @@
+import { type LocalInstallIdentity, type PublicInstallIdentity } from "./local-identity.js";
+export interface FreeInstallRegistrationOptions {
+    apiUrl?: string;
+    fetchImpl?: typeof fetch;
+}
+export declare function registerFreeInstall(input: {
+    identity: LocalInstallIdentity;
+    deviceLabel?: string;
+    repo?: Record<string, unknown>;
+    options?: FreeInstallRegistrationOptions;
+}): Promise<{
+    ok: boolean;
+    registeredAt: string;
+}>;
+export declare function tryRegisterFreeInstall(input: {
+    identity: LocalInstallIdentity;
+    deviceLabel?: string;
+    repo?: Record<string, unknown>;
+    options?: FreeInstallRegistrationOptions;
+}): Promise<{
+    ok: boolean;
+    registeredAt: string;
+} | {
+    ok: boolean;
+    error: string;
+}>;
+export declare function describeFreeIdentity(identity: PublicInstallIdentity): string;