@ai-sdlc/mcp-advisor 0.2.0 → 0.3.0

package/dist/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createMcpServer } from './server.js';
-const { server } = await createMcpServer();
+const workspacePath = process.env['AI_SDLC_WORKSPACE'] || undefined;
+const { server } = await createMcpServer({ workspacePath });
 await server.connect(new StdioServerTransport());
 //# sourceMappingURL=bin.js.map

package/dist/resources/index.js

@@ -4,6 +4,7 @@ import { registerHotspotsResource } from './hotspots.js';
 import { registerMyTasksResource } from './my-tasks.js';
 import { registerBudgetResource } from './budget.js';
 import { registerHistoryResource } from './history.js';
+import { registerUpdatesResource } from './updates.js';
 export function registerAllResources(server, deps) {
     registerCodebaseProfileResource(server, deps);
     registerConventionsResource(server, deps);
@@ -11,5 +12,6 @@ export function registerAllResources(server, deps) {
     registerMyTasksResource(server, deps);
     registerBudgetResource(server, deps);
     registerHistoryResource(server, deps);
+    registerUpdatesResource(server, deps);
 }
 //# sourceMappingURL=index.js.map

package/dist/resources/updates.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ServerDeps } from '../types.js';
+export declare function registerUpdatesResource(server: McpServer, deps: ServerDeps): void;
+//# sourceMappingURL=updates.d.ts.map

package/dist/resources/updates.js

@@ -0,0 +1,40 @@
+import { checkForUpdatesCached } from '../version-check.js';
+export function registerUpdatesResource(server, deps) {
+    server.resource('updates', 'ai-sdlc://updates', async () => {
+        const projectDirs = deps.workspace ? deps.workspace.repos.map((r) => r.path) : [deps.repoPath];
+        const result = await checkForUpdatesCached({ projectDirs });
+        if (!result.hasUpdates) {
+            return {
+                contents: [
+                    {
+                        uri: 'ai-sdlc://updates',
+                        mimeType: 'text/plain',
+                        text: 'All @ai-sdlc packages are up to date.',
+                    },
+                ],
+            };
+        }
+        const lines = [];
+        if (result.serverUpdateAvailable) {
+            lines.push(`MCP server: ${result.serverVersion} → ${result.serverLatest} (restart to apply)`);
+        }
+        for (const u of result.projectUpdates) {
+            if (u.updateAvailable) {
+                lines.push(`  ${u.package}: ${u.current} → ${u.latest} (${u.location})`);
+            }
+        }
+        if (result.autoUpdated.length > 0) {
+            lines.push('', `Auto-updated: ${result.autoUpdated.join(', ')}`);
+        }
+        return {
+            contents: [
+                {
+                    uri: 'ai-sdlc://updates',
+                    mimeType: 'text/plain',
+                    text: lines.join('\n') || 'All @ai-sdlc packages are up to date.',
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=updates.js.map

package/dist/server.d.ts

@@ -12,6 +12,8 @@ export interface CreateServerOptions {
     db?: InstanceType<typeof Database>;
     /** Repository path. Defaults to cwd. */
     repoPath?: string;
+    /** Workspace root path for multi-repo mode. Overrides repoPath for workspace detection. */
+    workspacePath?: string;
     /** Plugins to register additional tools/resources. */
     plugins?: McpAdvisorPlugin[];
 }

package/dist/server.js

@@ -2,6 +2,7 @@
  * MCP server factory — creates and wires the advisor server.
  */
 import { join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import Database from 'better-sqlite3';
 import { StateStore } from '@ai-sdlc/orchestrator/state';
@@ -9,12 +10,83 @@ import { CostTracker, loadConfig } from '@ai-sdlc/orchestrator';
 import { SessionManager } from './session.js';
 import { registerAllTools } from './tools/index.js';
 import { registerAllResources } from './resources/index.js';
+function loadWorkspaceRepos(workspacePath) {
+    const yamlPath = join(workspacePath, '.ai-sdlc', 'workspace.yaml');
+    if (!existsSync(yamlPath))
+        return [];
+    const content = readFileSync(yamlPath, 'utf-8');
+    // Simple extraction — repos are listed as "- name: X\n      path: Y"
+    const repos = [];
+    const nameRegex = /- name:\s*(.+)/g;
+    const pathRegex = /path:\s*(.+)/g;
+    const names = [];
+    const paths = [];
+    let m;
+    while ((m = nameRegex.exec(content)) !== null)
+        names.push(m[1].trim());
+    while ((m = pathRegex.exec(content)) !== null)
+        paths.push(m[1].trim());
+    for (let i = 0; i < names.length && i < paths.length; i++) {
+        repos.push({ name: names[i], path: paths[i] });
+    }
+    return repos;
+}
+function buildWorkspaceContext(workspacePath) {
+    const repoSpecs = loadWorkspaceRepos(workspacePath);
+    if (repoSpecs.length === 0)
+        return undefined;
+    // Shared workspace-level DB
+    const sharedDbPath = join(workspacePath, '.ai-sdlc', 'state.db');
+    const sharedDb = new Database(sharedDbPath);
+    const sharedStore = StateStore.open(sharedDb);
+    const repos = [];
+    for (const spec of repoSpecs) {
+        const repoAbsPath = join(workspacePath, spec.path.replace(/^\.\//, ''));
+        const dbPath = join(repoAbsPath, '.ai-sdlc', 'state.db');
+        // Only include repos that have been initialized
+        if (!existsSync(join(repoAbsPath, '.ai-sdlc')))
+            continue;
+        const db = new Database(dbPath);
+        const store = StateStore.open(db);
+        const costTracker = new CostTracker(store);
+        let config;
+        try {
+            config = loadConfig(join(repoAbsPath, '.ai-sdlc'));
+        }
+        catch {
+            // Config not available
+        }
+        repos.push({
+            name: spec.name,
+            path: repoAbsPath,
+            store,
+            costTracker,
+            config,
+        });
+    }
+    if (repos.length === 0)
+        return undefined;
+    return { workspacePath, repos, sharedStore };
+}
 export async function createMcpServer(opts) {
-    const db = opts?.db ?? new Database(opts?.dbPath ?? process.env['AI_SDLC_DB'] ?? '.ai-sdlc/state.db');
+    const workspacePath = opts?.workspacePath ?? process.env['AI_SDLC_WORKSPACE'];
+    // Determine primary repo/store
+    let db;
+    let repoPath;
+    if (workspacePath) {
+        // Workspace mode — primary store is workspace-level
+        repoPath = workspacePath;
+        db =
+            opts?.db ??
+                new Database(opts?.dbPath ?? process.env['AI_SDLC_DB'] ?? join(workspacePath, '.ai-sdlc', 'state.db'));
+    }
+    else {
+        repoPath = opts?.repoPath ?? process.cwd();
+        db = opts?.db ?? new Database(opts?.dbPath ?? process.env['AI_SDLC_DB'] ?? '.ai-sdlc/state.db');
+    }
     const store = StateStore.open(db);
     const costTracker = new CostTracker(store);
     const sessions = new SessionManager();
-    const repoPath = opts?.repoPath ?? process.cwd();
     // Load AI-SDLC config (best-effort — tools work in degraded mode without it)
     let config;
     try {
@@ -23,7 +95,12 @@ export async function createMcpServer(opts) {
     catch {
         // Config not available or invalid
     }
-    const deps = { store, costTracker, sessions, repoPath, config };
+    // Build workspace context if in multi-repo mode
+    let workspace;
+    if (workspacePath) {
+        workspace = buildWorkspaceContext(workspacePath);
+    }
+    const deps = { store, costTracker, sessions, repoPath, config, workspace };
     const server = new McpServer({
         name: 'ai-sdlc-advisor',
         version: '0.1.0',

package/dist/tools/index.d.ts

@@ -7,4 +7,5 @@ export { handleCheckTask } from './check-task.js';
 export { handleTrackUsage } from './track-usage.js';
 export { handleCheckFile } from './check-file.js';
 export { handleSessionEnd } from './session-end.js';
+export { handleListRepos } from './list-repos.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -4,6 +4,7 @@ import { registerCheckTask } from './check-task.js';
 import { registerTrackUsage } from './track-usage.js';
 import { registerCheckFile } from './check-file.js';
 import { registerSessionEnd } from './session-end.js';
+import { registerListRepos } from './list-repos.js';
 export function registerAllTools(server, deps) {
     registerSessionStart(server, deps);
     registerGetContext(server, deps);
@@ -11,6 +12,7 @@ export function registerAllTools(server, deps) {
     registerTrackUsage(server, deps);
     registerCheckFile(server, deps);
     registerSessionEnd(server, deps);
+    registerListRepos(server, deps);
 }
 export { handleSessionStart } from './session-start.js';
 export { handleGetContext } from './get-context.js';
@@ -18,4 +20,5 @@ export { handleCheckTask } from './check-task.js';
 export { handleTrackUsage } from './track-usage.js';
 export { handleCheckFile } from './check-file.js';
 export { handleSessionEnd } from './session-end.js';
+export { handleListRepos } from './list-repos.js';
 //# sourceMappingURL=index.js.map

package/dist/tools/list-repos.d.ts

@@ -0,0 +1,13 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ServerDeps } from '../types.js';
+export interface ListReposResult {
+    isWorkspace: boolean;
+    repos: Array<{
+        name: string;
+        path: string;
+        hasConfig: boolean;
+    }>;
+}
+export declare function handleListRepos(deps: ServerDeps): ListReposResult;
+export declare function registerListRepos(server: McpServer, deps: ServerDeps): void;
+//# sourceMappingURL=list-repos.d.ts.map

package/dist/tools/list-repos.js

@@ -0,0 +1,23 @@
+export function handleListRepos(deps) {
+    if (!deps.workspace) {
+        return {
+            isWorkspace: false,
+            repos: [{ name: 'current', path: deps.repoPath, hasConfig: !!deps.config }],
+        };
+    }
+    return {
+        isWorkspace: true,
+        repos: deps.workspace.repos.map((r) => ({
+            name: r.name,
+            path: r.path,
+            hasConfig: !!r.config,
+        })),
+    };
+}
+export function registerListRepos(server, deps) {
+    server.tool('list_repos', 'List repositories in the workspace. In single-repo mode, returns the current repo.', {}, async () => {
+        const result = handleListRepos(deps);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+}
+//# sourceMappingURL=list-repos.js.map

package/dist/tools/session-start.d.ts

@@ -5,6 +5,7 @@ export interface SessionStartResult {
     linkedIssue: number | null;
     linkMethod: string | null;
     project: string;
+    updateNotice?: string;
 }
 export declare function handleSessionStart(deps: ServerDeps, input: {
     developer: string;

package/dist/tools/session-start.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { resolveIssue } from '../issue-linker.js';
 import { randomUUID } from 'node:crypto';
+import { checkForUpdatesCached } from '../version-check.js';
 export async function handleSessionStart(deps, input) {
     const session = deps.sessions.create({
         developer: input.developer,
@@ -22,12 +23,33 @@ export async function handleSessionStart(deps, input) {
             linkMethod: resolution.method,
         }),
     });
-    return {
+    // Check for package updates and auto-update project deps (non-blocking, cached)
+    let updateNotice;
+    try {
+        const projectDirs = deps.workspace ? deps.workspace.repos.map((r) => r.path) : [deps.repoPath];
+        const versionCheck = await checkForUpdatesCached({ projectDirs });
+        const notices = [];
+        if (versionCheck.autoUpdated.length > 0) {
+            notices.push(`Auto-updated: ${versionCheck.autoUpdated.join(', ')}`);
+        }
+        if (versionCheck.serverUpdateAvailable) {
+            notices.push(`MCP server update: ${versionCheck.serverVersion} → ${versionCheck.serverLatest}. Restart to apply.`);
+        }
+        if (notices.length > 0)
+            updateNotice = notices.join('. ');
+    }
+    catch {
+        // Version check is best-effort
+    }
+    const result = {
         sessionId: session.sessionId,
         linkedIssue: resolution.issueNumber,
         linkMethod: resolution.method,
         project: session.project,
     };
+    if (updateNotice)
+        result.updateNotice = updateNotice;
+    return result;
 }
 export function registerSessionStart(server, deps) {
     server.tool('session_start', 'Start a governed AI session. Returns session ID, linked issue, and project context.', {

package/dist/types.d.ts

@@ -4,6 +4,19 @@
 import type { StateStore } from '@ai-sdlc/orchestrator/state';
 import type { CostTracker, AiSdlcConfig } from '@ai-sdlc/orchestrator';
 import type { SessionManager } from './session.js';
+export interface RepoContext {
+    name: string;
+    path: string;
+    store: StateStore;
+    costTracker: CostTracker;
+    config?: AiSdlcConfig;
+}
+export interface WorkspaceContext {
+    workspacePath: string;
+    repos: RepoContext[];
+    /** Shared workspace-level store for cross-repo knowledge. */
+    sharedStore: StateStore;
+}
 export interface ServerDeps {
     store: StateStore;
     costTracker: CostTracker;
@@ -11,5 +24,7 @@ export interface ServerDeps {
     repoPath: string;
     /** Loaded AI-SDLC config (if available). */
     config?: AiSdlcConfig;
+    /** Workspace context when running in multi-repo mode. */
+    workspace?: WorkspaceContext;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/version-check.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Version check and auto-update — keep @ai-sdlc packages up to date.
+ *
+ * Strategy:
+ * - The MCP server itself runs via `npx -y` so it re-fetches on cold start.
+ * - Project-level @ai-sdlc/* dependencies are detected by scanning package.json
+ *   files in workspace repos and auto-updated via the user's package manager.
+ * - Checks run at most once per 6 hours (cached).
+ */
+export interface VersionInfo {
+    package: string;
+    current: string;
+    latest: string | null;
+    updateAvailable: boolean;
+    location?: string;
+}
+export interface VersionCheckResult {
+    serverVersion: string;
+    serverLatest: string | null;
+    serverUpdateAvailable: boolean;
+    projectUpdates: VersionInfo[];
+    hasUpdates: boolean;
+    autoUpdated: string[];
+}
+export interface CheckForUpdatesOptions {
+    /** Directories to scan for @ai-sdlc/* dependencies. */
+    projectDirs?: string[];
+    /** Whether to auto-update outdated project dependencies. Default: true. */
+    autoUpdate?: boolean;
+}
+export declare function checkForUpdates(opts?: CheckForUpdatesOptions): Promise<VersionCheckResult>;
+/** Cached version check — runs at most once per 6 hours. */
+export declare function checkForUpdatesCached(opts?: CheckForUpdatesOptions): Promise<VersionCheckResult>;
+//# sourceMappingURL=version-check.d.ts.map

package/dist/version-check.js

@@ -0,0 +1,175 @@
+/**
+ * Version check and auto-update — keep @ai-sdlc packages up to date.
+ *
+ * Strategy:
+ * - The MCP server itself runs via `npx -y` so it re-fetches on cold start.
+ * - Project-level @ai-sdlc/* dependencies are detected by scanning package.json
+ *   files in workspace repos and auto-updated via the user's package manager.
+ * - Checks run at most once per 6 hours (cached).
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+function getServerVersion() {
+    try {
+        const thisDir = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(thisDir, '..', 'package.json'), 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+async function fetchLatestVersion(packageName) {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function isNewer(latest, current) {
+    const parse = (v) => v
+        .replace(/^[~^>=<]*/, '')
+        .split('.')
+        .map(Number);
+    const l = parse(latest);
+    const c = parse(current);
+    for (let i = 0; i < 3; i++) {
+        if ((l[i] ?? 0) > (c[i] ?? 0))
+            return true;
+        if ((l[i] ?? 0) < (c[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+/** Scan a directory's package.json for @ai-sdlc/* dependencies. */
+function scanProjectDeps(projectDir) {
+    const pkgPath = join(projectDir, 'package.json');
+    if (!existsSync(pkgPath))
+        return [];
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        const deps = [];
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        for (const [name, version] of Object.entries(allDeps)) {
+            if (!name.startsWith('@ai-sdlc/'))
+                continue;
+            const v = String(version);
+            // Skip workspace/file/link references
+            if (v.startsWith('workspace:') || v.startsWith('file:') || v.startsWith('link:'))
+                continue;
+            deps.push({ packageName: name, currentVersion: v, location: projectDir });
+        }
+        return deps;
+    }
+    catch {
+        return [];
+    }
+}
+function detectPackageManager(projectDir) {
+    if (existsSync(join(projectDir, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(projectDir, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+function runUpdate(projectDir, packages) {
+    if (packages.length === 0)
+        return false;
+    const pm = detectPackageManager(projectDir);
+    const pkgList = packages.join(' ');
+    try {
+        const cmd = pm === 'pnpm'
+            ? `pnpm update ${pkgList}`
+            : pm === 'yarn'
+                ? `yarn upgrade ${pkgList}`
+                : `npm update ${pkgList}`;
+        execSync(cmd, { cwd: projectDir, stdio: 'ignore', timeout: 30000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkForUpdates(opts) {
+    const autoUpdate = opts?.autoUpdate ?? true;
+    const projectDirs = opts?.projectDirs ?? [];
+    // 1. Check if the MCP server itself has a newer version
+    const serverVersion = getServerVersion();
+    const serverLatest = await fetchLatestVersion('@ai-sdlc/mcp-advisor');
+    const serverUpdateAvailable = serverLatest ? isNewer(serverLatest, serverVersion) : false;
+    // 2. Scan project dependencies
+    const allDeps = [];
+    for (const dir of projectDirs) {
+        allDeps.push(...scanProjectDeps(dir));
+    }
+    // Deduplicate by package name (keep first occurrence)
+    const seen = new Set();
+    const uniqueDeps = allDeps.filter((d) => {
+        const key = `${d.packageName}@${d.location}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    // 3. Check each dependency against npm registry
+    const projectUpdates = await Promise.all(uniqueDeps.map(async (dep) => {
+        const latest = await fetchLatestVersion(dep.packageName);
+        return {
+            package: dep.packageName,
+            current: dep.currentVersion,
+            latest,
+            updateAvailable: latest ? isNewer(latest, dep.currentVersion) : false,
+            location: dep.location,
+        };
+    }));
+    // 4. Auto-update outdated project dependencies
+    const autoUpdated = [];
+    if (autoUpdate) {
+        // Group outdated deps by project directory
+        const byDir = new Map();
+        for (const u of projectUpdates) {
+            if (!u.updateAvailable || !u.location)
+                continue;
+            const list = byDir.get(u.location) ?? [];
+            list.push(`${u.package}@latest`);
+            byDir.set(u.location, list);
+        }
+        for (const [dir, packages] of byDir) {
+            if (runUpdate(dir, packages)) {
+                autoUpdated.push(...packages.map((p) => p.replace(/@latest$/, '')));
+            }
+        }
+    }
+    const hasUpdates = serverUpdateAvailable || projectUpdates.some((u) => u.updateAvailable);
+    return {
+        serverVersion,
+        serverLatest,
+        serverUpdateAvailable,
+        projectUpdates,
+        hasUpdates,
+        autoUpdated,
+    };
+}
+let cachedResult = null;
+let cacheTime = 0;
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000; // 6 hours
+/** Cached version check — runs at most once per 6 hours. */
+export async function checkForUpdatesCached(opts) {
+    if (cachedResult && Date.now() - cacheTime < CACHE_TTL_MS) {
+        return cachedResult;
+    }
+    cachedResult = await checkForUpdates(opts);
+    cacheTime = Date.now();
+    return cachedResult;
+}
+//# sourceMappingURL=version-check.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdlc/mcp-advisor",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "MCP server bridging human-directed AI sessions with the AI-SDLC orchestrator",
   "license": "Apache-2.0",
   "repository": {
@@ -33,7 +33,7 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "better-sqlite3": "^11.0.0",
     "zod": "^3.23.0",
-    "@ai-sdlc/orchestrator": "0.2.0"
+    "@ai-sdlc/orchestrator": "0.3.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.0",