@askthew/mcp-plugin 0.2.8 → 0.4.2

package/dist/lib/upgrade-sync.js

@@ -0,0 +1,60 @@
+export function syncDryRun(store) {
+    const pendingSignals = store.listSignals({ limit: 100000 }).filter((signal) => !store.getMeta(`signal_uploaded:${signal.id}`));
+    const pendingDecisions = store.listDecisions({ limit: 100000, pendingUploadOnly: true });
+    const alreadySignals = store.listSignals({ limit: 100000 }).length - pendingSignals.length;
+    const alreadyDecisions = store.listDecisions({ limit: 100000 }).filter((decision) => decision.uploadedAt).length;
+    return {
+        pending: { signals: pendingSignals.length, decisions: pendingDecisions.length },
+        alreadyUploaded: { signals: alreadySignals, decisions: alreadyDecisions },
+    };
+}
+export async function uploadLocalStore(input) {
+    if (input.dryRun) {
+        return { ok: true, dryRun: true, ...syncDryRun(input.store) };
+    }
+    const fetcher = input.fetchImpl ?? fetch;
+    const apiUrl = (input.apiUrl ?? input.credentials.apiUrl ?? process.env.ASKTHEW_API_URL ?? "https://app.askthew.com").replace(/\/$/, "");
+    const token = input.syncToken ?? input.credentials.cliToken;
+    const signalRows = input.store
+        .listSignals({ limit: 100000 })
+        .filter((signal) => !input.store.getMeta(`signal_uploaded:${signal.id}`));
+    const decisionRows = input.store.listDecisions({ limit: 100000, pendingUploadOnly: true }).reverse();
+    let uploadedSignals = 0;
+    let uploadedDecisions = 0;
+    for (const chunk of chunks(signalRows, 100)) {
+        await postChunk(apiUrl, token, fetcher, "signals", chunk);
+        for (const signal of chunk) {
+            input.store.setMeta(`signal_uploaded:${signal.id}`, new Date().toISOString());
+        }
+        uploadedSignals += chunk.length;
+    }
+    for (const chunk of chunks(decisionRows, 100)) {
+        await postChunk(apiUrl, token, fetcher, "decisions", chunk);
+        for (const decision of chunk) {
+            input.store.updateDecision(decision.id, { uploadedAt: new Date().toISOString() });
+        }
+        uploadedDecisions += chunk.length;
+    }
+    return { ok: true, uploaded: { signals: uploadedSignals, decisions: uploadedDecisions } };
+}
+async function postChunk(apiUrl, token, fetcher, kind, items) {
+    const response = await fetcher(`${apiUrl}/api/cli/v1/upgrade/sync`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ uploadVersion: 1, kind, items }),
+    });
+    if (!response.ok) {
+        const body = await response.json().catch(() => null);
+        throw new Error(body?.error ? String(body.error) : `Upload failed for ${kind}.`);
+    }
+}
+function chunks(items, size) {
+    const result = [];
+    for (let index = 0; index < items.length; index += size) {
+        result.push(items.slice(index, index + size));
+    }
+    return result;
+}

package/dist/local-identity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/local-identity.test.js

@@ -0,0 +1,29 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ensureLocalIdentity, signLocalIdentityPayload } from "./lib/local-identity.js";
+import { identityPath } from "./lib/paths.js";
+test("local identity uses install id as primary identity and signs summary payloads", () => {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-local-identity-"));
+    try {
+        const env = { ASKTHEW_DATA_DIR: dataDir };
+        const identity = ensureLocalIdentity({
+            emailClaim: "Founder@Example.com",
+            apiUrl: "https://app.askthew.com",
+            env,
+        });
+        const body = JSON.stringify({ schemaVersion: 1, activity: { signalCount: 1 } });
+        const signed = signLocalIdentityPayload({ identity, body, timestamp: "2026-05-07T12:00:00.000Z" });
+        assert.match(identity.installId, /^[0-9a-f-]{36}$/);
+        assert.equal(identity.emailClaim, "founder@example.com");
+        assert.equal(fs.existsSync(identityPath(env)), true);
+        assert.equal(crypto.verify(null, Buffer.from(`${signed.timestamp}.${body}`), identity.publicKey, Buffer.from(signed.signature, "base64url")), true);
+        assert.equal(crypto.verify(null, Buffer.from(`${signed.timestamp}.${JSON.stringify({ tampered: true })}`), identity.publicKey, Buffer.from(signed.signature, "base64url")), false);
+    }
+    finally {
+        fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+});

package/dist/local-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/local-store.test.js

@@ -0,0 +1,71 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { LocalStore } from "./lib/local-store.js";
+test("local store migrates, captures signals, decisions, and FIFO telemetry", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-store-"));
+    const store = LocalStore.open({ path: path.join(dir, "store.sqlite") });
+    const signal = store.insertSignal({
+        sessionId: "s1",
+        sequence: 1,
+        kind: "session_checkpoint",
+        summary: "Checkpoint",
+        filesTouched: ["src/app.ts"],
+        commandsRun: ["npm test"],
+    });
+    const duplicate = store.insertSignal({
+        sessionId: "s1",
+        sequence: 1,
+        kind: "session_checkpoint",
+        summary: "Checkpoint duplicate",
+    });
+    const decision = store.createDecision({
+        rawContent: "Use local SQLite for free-tier capture.",
+        sessionId: "s1",
+        sourceSignalIds: [signal.id],
+    });
+    const firstOutbox = store.enqueueTelemetry({ n: 1 });
+    const secondOutbox = store.enqueueTelemetry({ n: 2 });
+    assert.equal(signal.id, duplicate.id);
+    assert.equal(store.listSignals({ sessionId: "s1" }).length, 1);
+    assert.equal(store.getDecision(decision.id)?.headline, "Use local SQLite for free-tier capture.");
+    assert.deepEqual(store.listTelemetryOutbox().map((row) => row.id), [firstOutbox, secondOutbox]);
+    store.close();
+    fs.rmSync(dir, { recursive: true, force: true });
+});
+test("local store scopes trail rows, links decisions, and tracks lifecycle timestamps", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-store-scope-"));
+    const store = LocalStore.open({ path: path.join(dir, "store.sqlite") });
+    const scoped = store.insertSignal({
+        sessionId: "s1",
+        sequence: 1,
+        kind: "direction_change",
+        summary: "Let's go with local search because it is fast.",
+        scopeKey: "repo-a",
+    });
+    store.insertSignal({
+        sessionId: "s2",
+        sequence: 1,
+        kind: "direction_change",
+        summary: "Use a different decision in another repo.",
+        scopeKey: "repo-b",
+    });
+    const decision = store.createDecision({
+        rawContent: "Adopt local search.",
+        sessionId: "s1",
+        sourceSignalIds: [scoped.id],
+        scopeKey: "repo-a",
+    });
+    const committed = store.updateDecision(decision.id, { status: "committed" });
+    assert.equal(store.listSignals({ scopeKey: "repo-a" }).length, 1);
+    assert.equal(store.listSignals({ scopeKey: "repo-b" }).length, 1);
+    assert.equal(store.listDecisions({ scopeKey: "repo-a" }).length, 1);
+    assert.equal(store.getDecisionForSignal(scoped.id)?.id, decision.id);
+    assert.equal(Boolean(decision.proposedAt), true);
+    assert.equal(Boolean(committed?.committedAt), true);
+    assert.equal(store.mostRecentSessionId({ scopeKey: "repo-a" }), "s1");
+    store.close();
+    fs.rmSync(dir, { recursive: true, force: true });
+});

package/dist/scope.d.ts

@@ -4,5 +4,4 @@ export interface PluginScope {
     appPath?: string;
     serviceName?: string;
 }
-export declare function resolvePluginScope(startDirectory?: string): PluginScope;
-export declare function resolveFunctionalAreaFromToml(startDirectory?: string): string;
+export declare function resolvePluginScope(startDirectory?: string, env?: NodeJS.ProcessEnv): PluginScope;

package/dist/scope.js

@@ -1,6 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 const REPO_MARKERS = [".git", "package.json", "pyproject.toml", "go.mod", "Cargo.toml"];
+const PROJECT_ROOT_ENV_KEYS = [
+    "ASKTHEW_REPO_ROOT",
+    "ASKTHEW_PROJECT_ROOT",
+    "CODEX_WORKSPACE",
+    "CODEX_PROJECT_DIR",
+    "CLAUDE_PROJECT_DIR",
+    "MCP_PROJECT_ROOT",
+    "PROJECT_ROOT",
+    "WORKSPACE_FOLDER",
+    "GITHUB_WORKSPACE",
+    "INIT_CWD",
+    "PWD",
+];
 function parseAskTheWToml(filePath) {
     if (!fs.existsSync(filePath)) {
         return {};
@@ -15,7 +28,6 @@ function parseAskTheWToml(filePath) {
         repoRoot: readValue("repo_root"),
         appPath: readValue("app_path"),
         serviceName: readValue("service_name"),
-        functionalArea: readValue("functional_area"),
     };
 }
 function findRepoRoot(startDirectory) {
@@ -36,10 +48,51 @@ function findRepoRoot(startDirectory) {
     }
     return highestMarkerDirectory;
 }
-export function resolvePluginScope(startDirectory = process.cwd()) {
+function cleanEnv(value) {
+    return String(value ?? "").trim().replace(/^['"]/, "").replace(/['"]$/, "");
+}
+function explicitEnvScope(env) {
+    const repoName = cleanEnv(env.ASKTHEW_REPO_NAME);
+    const repoRoot = cleanEnv(env.ASKTHEW_REPO_ROOT);
+    const appPath = cleanEnv(env.ASKTHEW_APP_PATH);
+    const serviceName = cleanEnv(env.ASKTHEW_SERVICE_NAME);
+    if (!repoName && !repoRoot) {
+        return null;
+    }
+    const resolvedRoot = repoRoot ? path.resolve(repoRoot) : undefined;
+    return {
+        repoName: repoName || path.basename(resolvedRoot ?? process.cwd()),
+        ...(resolvedRoot ? { repoRoot: resolvedRoot } : {}),
+        ...(appPath ? { appPath } : {}),
+        ...(serviceName ? { serviceName } : {}),
+    };
+}
+function envRepoRoot(env) {
+    for (const key of PROJECT_ROOT_ENV_KEYS) {
+        const value = cleanEnv(env[key]);
+        if (!value)
+            continue;
+        const candidate = findRepoRoot(value);
+        if (candidate)
+            return candidate;
+    }
+    return null;
+}
+export function resolvePluginScope(startDirectory = process.cwd(), env = process.env) {
     const cwd = path.resolve(startDirectory);
+    const envScope = explicitEnvScope(env);
+    if (envScope) {
+        return envScope;
+    }
     const parsedConfig = parseAskTheWToml(path.join(cwd, ".asktheworld.toml"));
-    const repoRoot = parsedConfig.repoRoot || findRepoRoot(cwd) || cwd;
+    const discoveredRoot = findRepoRoot(cwd);
+    const fallbackEnvRoot = envRepoRoot(env);
+    const repoRoot = parsedConfig.repoRoot ||
+        (fallbackEnvRoot && (!discoveredRoot || path.basename(discoveredRoot) === "task")
+            ? fallbackEnvRoot
+            : discoveredRoot) ||
+        fallbackEnvRoot ||
+        cwd;
     const repoName = parsedConfig.repoName || path.basename(repoRoot);
     const relativePath = path.relative(repoRoot, cwd);
     const normalizedRelativePath = relativePath && relativePath !== "." && !relativePath.startsWith("..")
@@ -53,8 +106,3 @@ export function resolvePluginScope(startDirectory = process.cwd()) {
         ...(parsedConfig.serviceName ? { serviceName: parsedConfig.serviceName } : {}),
     };
 }
-export function resolveFunctionalAreaFromToml(startDirectory = process.cwd()) {
-    const cwd = path.resolve(startDirectory);
-    const parsedConfig = parseAskTheWToml(path.join(cwd, ".asktheworld.toml"));
-    return parsedConfig.functionalArea || "";
-}

package/dist/scope.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scope.test.js

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolvePluginScope } from "./scope.js";
+test("resolvePluginScope derives repo and app path from cwd", () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-scope-"));
+    const repoRoot = path.join(tempRoot, "repo");
+    const appRoot = path.join(repoRoot, "apps", "landing");
+    fs.mkdirSync(path.join(repoRoot, ".git"), { recursive: true });
+    fs.mkdirSync(appRoot, { recursive: true });
+    const scope = resolvePluginScope(appRoot);
+    assert.equal(scope.repoName, "repo");
+    assert.equal(scope.repoRoot, repoRoot);
+    assert.equal(scope.appPath, "apps/landing");
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+test("resolvePluginScope respects explicit .asktheworld.toml values", () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-scope-config-"));
+    fs.mkdirSync(tempRoot, { recursive: true });
+    fs.writeFileSync(path.join(tempRoot, ".asktheworld.toml"), [
+        'repo_name = "main-platform"',
+        'app_path = "apps/decisions"',
+        'service_name = "decisions"',
+    ].join("\n"), "utf8");
+    const scope = resolvePluginScope(tempRoot);
+    assert.equal(scope.repoName, "main-platform");
+    assert.equal(scope.appPath, "apps/decisions");
+    assert.equal(scope.serviceName, "decisions");
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+test("resolvePluginScope prefers install-time repo env over npx sandbox cwd", () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-scope-env-"));
+    const repoRoot = path.join(tempRoot, "ThesisEngine-main");
+    const sandboxRoot = path.join(tempRoot, "task");
+    fs.mkdirSync(path.join(repoRoot, ".git"), { recursive: true });
+    fs.mkdirSync(sandboxRoot, { recursive: true });
+    fs.writeFileSync(path.join(sandboxRoot, "package.json"), "{}", "utf8");
+    const scope = resolvePluginScope(sandboxRoot, {
+        ASKTHEW_REPO_NAME: "ThesisEngine-main",
+        ASKTHEW_REPO_ROOT: repoRoot,
+        ASKTHEW_APP_PATH: "apps/app",
+    });
+    assert.equal(scope.repoName, "ThesisEngine-main");
+    assert.equal(scope.repoRoot, repoRoot);
+    assert.equal(scope.appPath, "apps/app");
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});

package/dist/timeline-insights.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/timeline-insights.test.js

@@ -0,0 +1,85 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { buildTimelineInsights, buildLocalTimeline } from "./lib/timeline-insights.js";
+function signal(id, day) {
+    return {
+        id,
+        sessionId: "session-a",
+        sequence: id,
+        kind: "session_checkpoint",
+        summary: "checkpoint",
+        evidence: [],
+        filesTouched: [],
+        commandsRun: [],
+        metadata: {},
+        capturedAt: `${day}T10:00:00.000Z`,
+    };
+}
+test("local timeline buckets signals and decisions by day", () => {
+    const decisions = [{
+            id: "d1",
+            sessionId: "session-a",
+            headline: "Decision",
+            why: null,
+            status: "proposed",
+            alignment: null,
+            files: [],
+            sourceSignalIds: [],
+            rawContent: "Decision",
+            createdAt: "2026-05-01T11:00:00.000Z",
+            updatedAt: "2026-05-01T11:00:00.000Z",
+            uploadedAt: null,
+        }];
+    const points = buildLocalTimeline({
+        scope: "day",
+        signals: [signal(1, "2026-05-01"), signal(2, "2026-05-02")],
+        decisions,
+    });
+    assert.deepEqual(points.map((point) => [point.x, point.signalCount, point.decisionCount]), [
+        ["2026-05-01", 1, 1],
+        ["2026-05-02", 1, 0],
+    ]);
+});
+test("local timeline insight ids stay in timeline namespace", () => {
+    const insights = buildTimelineInsights([{ x: "2026-05-01", signalCount: 20, decisionCount: 1 }]);
+    assert.ok(insights.every((insight) => insight.id.startsWith("timeline.")));
+});
+test("session timeline buckets by sessionId without inventing Other", () => {
+    const decisions = [
+        {
+            id: "d1",
+            sessionId: null,
+            headline: "Decision without session",
+            why: null,
+            status: "proposed",
+            alignment: null,
+            files: [],
+            sourceSignalIds: [],
+            rawContent: "Decision without session",
+            createdAt: "2026-05-01T11:00:00.000Z",
+            updatedAt: "2026-05-01T11:00:00.000Z",
+            uploadedAt: null,
+        },
+        {
+            id: "d2",
+            sessionId: "session-a",
+            headline: "Decision with session",
+            why: null,
+            status: "proposed",
+            alignment: null,
+            files: [],
+            sourceSignalIds: [],
+            rawContent: "Decision with session",
+            createdAt: "2026-05-01T11:00:00.000Z",
+            updatedAt: "2026-05-01T11:00:00.000Z",
+            uploadedAt: null,
+        },
+    ];
+    const points = buildLocalTimeline({
+        scope: "session",
+        signals: [signal(1, "2026-05-01")],
+        decisions,
+    });
+    assert.deepEqual(points.map((point) => point.x), ["session-a"]);
+    assert.equal(points[0]?.decisionCount, 1);
+});

package/dist/tip-engine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tip-engine.test.js

@@ -0,0 +1,51 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { analyzeLocalPatterns } from "./lib/tip-engine.js";
+function signal(id, kind, summary = "ok") {
+    return {
+        id,
+        sessionId: "s1",
+        sequence: id,
+        kind,
+        summary,
+        evidence: [],
+        filesTouched: [`file${id}.ts`],
+        commandsRun: [],
+        metadata: {},
+        capturedAt: "2026-05-05T10:00:00.000Z",
+    };
+}
+test("tip engine is deterministic and sorts top severity first", () => {
+    const signals = [
+        signal(1, "direction_change"),
+        signal(2, "direction_change"),
+        signal(3, "direction_change"),
+        signal(4, "direction_change"),
+        signal(5, "verification_result", "failed"),
+        signal(6, "verification_result", "failed"),
+        signal(7, "verification_result", "failed"),
+        signal(8, "verification_result", "passed"),
+    ];
+    const decisions = [1, 2, 3].map((index) => ({
+        id: `d_${index}`,
+        sessionId: "s1",
+        headline: `Decision ${index}`,
+        why: "",
+        status: "proposed",
+        alignment: null,
+        files: [],
+        sourceSignalIds: [],
+        rawContent: `Decision ${index}`,
+        createdAt: "2026-05-01T10:00:00.000Z",
+        updatedAt: "2026-05-01T10:00:00.000Z",
+        uploadedAt: null,
+    }));
+    const first = analyzeLocalPatterns({ signals, decisions, now: new Date("2026-05-05T10:00:00.000Z") });
+    const second = analyzeLocalPatterns({ signals, decisions, now: new Date("2026-05-05T10:00:00.000Z") });
+    assert.deepEqual(first, second);
+    assert.equal(first.length, 3);
+    assert.equal(first[0]?.severity, "high");
+});
+test("tip engine stays quiet on empty input", () => {
+    assert.deepEqual(analyzeLocalPatterns({ signals: [], decisions: [] }), []);
+});

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@askthew/mcp-plugin",
-  "version": "0.2.8",
+  "version": "0.4.2",
   "private": false,
-  "description": "Ask The W MCP connector for capturing compact coding-agent session signals.",
+  "description": "Ask The W plugin connector for local-first coding-agent decisions, signals, and review.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -11,14 +11,8 @@
   },
   "files": [
     "README.md",
-    "dist/cli.d.ts",
-    "dist/cli.js",
-    "dist/index.d.ts",
-    "dist/index.js",
-    "dist/install.d.ts",
-    "dist/install.js",
-    "dist/scope.d.ts",
-    "dist/scope.js"
+    "dist/**/*.d.ts",
+    "dist/**/*.js"
   ],
   "keywords": [
     "askthew",
@@ -57,6 +51,9 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.3.0",
+    "better-sqlite3": "^11.10.0",
+    "nanoid": "^5.1.5",
+    "prompts": "^2.4.2",
     "zod": "^3.24.2"
   },
   "devDependencies": {