toolnet-memory 0.2.21 → 0.3.0

package/dist/sdk/remote-client.js

@@ -0,0 +1,185 @@
+export class ToolNetApiClient {
+    baseUrl;
+    token;
+    principal;
+    timeoutMs;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/u, '');
+        this.token = options.token;
+        this.principal = options.principal;
+        this.timeoutMs = options.timeoutMs ?? 10_000;
+    }
+    health() {
+        return this.request('/v1/health');
+    }
+    project() {
+        return this.request('/v1/project');
+    }
+    memoryAsk(input) {
+        return this.request('/v1/memory/ask', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    memorySearch(input) {
+        return this.request('/v1/memory/search', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    skillSearch(input) {
+        return this.request('/v1/skills/search', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    offloadRead(input) {
+        return this.request('/v1/offload/read', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    hub() {
+        return this.request('/v1/hub');
+    }
+    hubTeams() {
+        return this.request('/v1/hub/teams');
+    }
+    createHubTeam(input) {
+        return this.request('/v1/hub/teams', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    hubAgents() {
+        return this.request('/v1/hub/agents');
+    }
+    createHubAgent(input) {
+        return this.request('/v1/hub/agents', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    hubAcl() {
+        return this.request('/v1/hub/acl');
+    }
+    grantHubAcl(input) {
+        return this.request('/v1/hub/acl/grant', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    revokeHubAcl(principal) {
+        return this.request('/v1/hub/acl/revoke', {
+            method: 'POST',
+            body: JSON.stringify({ principal }),
+        });
+    }
+    hubLoadouts() {
+        return this.request('/v1/hub/loadouts');
+    }
+    setHubLoadout(input) {
+        return this.request('/v1/hub/loadouts', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    hubObservability() {
+        return this.request('/v1/hub/observability');
+    }
+    wiki() {
+        return this.request('/v1/wiki');
+    }
+    wikiPages() {
+        return this.request('/v1/wiki/pages');
+    }
+    createWikiPage(input) {
+        return this.request('/v1/wiki/pages', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    wikiPage(slug) {
+        return this.request(`/v1/wiki/pages/${encodeURIComponent(slug)}`);
+    }
+    updateWikiPage(slug, input) {
+        return this.request(`/v1/wiki/pages/${encodeURIComponent(slug)}`, {
+            method: 'PUT',
+            body: JSON.stringify(input),
+        });
+    }
+    wikiSearch(query, limit = 10) {
+        const params = new URLSearchParams({
+            q: query,
+            limit: String(limit),
+        });
+        return this.request(`/v1/wiki/search?${params.toString()}`);
+    }
+    wikiHistory(slug) {
+        return this.request(`/v1/wiki/pages/${encodeURIComponent(slug)}/history`);
+    }
+    wikiBacklinks(slug) {
+        return this.request(`/v1/wiki/pages/${encodeURIComponent(slug)}/backlinks`);
+    }
+    governance() {
+        return this.request('/v1/governance');
+    }
+    governanceReviews(status) {
+        const suffix = status ? `?status=${encodeURIComponent(status)}` : '';
+        return this.request(`/v1/governance/reviews${suffix}`);
+    }
+    reviewKnowledge(reviewId, input) {
+        return this.request(`/v1/governance/reviews/${encodeURIComponent(reviewId)}`, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    knowledgeQuality() {
+        return this.request('/v1/governance/quality');
+    }
+    governancePolicy() {
+        return this.request('/v1/governance/policy');
+    }
+    setGovernancePolicy(input) {
+        return this.request('/v1/governance/policy', {
+            method: 'PUT',
+            body: JSON.stringify(input),
+        });
+    }
+    async request(path, init = {}) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort();
+        }, this.timeoutMs);
+        try {
+            const headers = new Headers(init.headers);
+            headers.set('accept', 'application/json');
+            if (init.body !== undefined) {
+                headers.set('content-type', 'application/json');
+            }
+            if (this.token) {
+                headers.set('authorization', `Bearer ${this.token}`);
+            }
+            if (this.principal) {
+                headers.set('x-toolnet-principal', this.principal);
+            }
+            const response = await fetch(`${this.baseUrl}${path}`, {
+                ...init,
+                headers,
+                signal: controller.signal,
+            });
+            const text = await response.text();
+            const body = text ? JSON.parse(text) : null;
+            if (!response.ok) {
+                const message = body && typeof body === 'object' && 'error' in body && typeof body.error === 'string'
+                    ? body.error
+                    : `ToolNet API request failed: HTTP ${response.status}`;
+                throw new Error(message);
+            }
+            return body;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/sdk/types.d.ts

@@ -0,0 +1,402 @@
+export interface ToolNetApiClientOptions {
+    baseUrl: string;
+    token?: string;
+    principal?: string;
+    timeoutMs?: number;
+}
+export interface ToolNetApiHealth {
+    ok: true;
+    service: 'toolnet-memory';
+    schema: 'toolnet.api-health.v1';
+    project: {
+        id: string;
+        name: string;
+        remote: string;
+    };
+}
+export interface ToolNetApiProject {
+    schema: 'toolnet.api-project.v1';
+    project: {
+        id: string;
+        name: string;
+        remote: string;
+        graphVersion: number;
+        memoryVersion: number;
+        createdAt: string;
+        updatedAt: string;
+    };
+}
+export interface ToolNetApiMemoryAskInput {
+    question: string;
+    mode?: 'ai' | 'local';
+}
+export interface ToolNetApiMemoryAsk {
+    schema: 'toolnet.api-memory-ask.v1';
+    result: {
+        answer: string;
+        mode: 'ai' | 'local';
+        usedAi: boolean;
+        source?: string;
+        intent?: string;
+        provider?: string;
+        model?: string;
+    };
+}
+export interface ToolNetApiMemorySearchInput {
+    query: string;
+    limit?: number;
+}
+export interface ToolNetApiMemorySearchResult {
+    id: string;
+    type: 'code' | 'activity' | 'decision' | 'rule' | 'todo' | 'summary';
+    content: string;
+    importance: 'critical' | 'high' | 'normal' | 'temporary';
+    score: number;
+    tags: string[];
+}
+export interface ToolNetApiMemorySearch {
+    schema: 'toolnet.api-memory-search.v1';
+    results: ToolNetApiMemorySearchResult[];
+}
+export interface ToolNetApiSkillSearchInput {
+    query: string;
+    limit?: number;
+}
+export interface ToolNetApiSkillSource {
+    agent: string;
+    nativeSessionId: string;
+    sessionKey: string;
+    firstSequence: number;
+    lastSequence: number;
+    eventIds: string[];
+}
+export interface ToolNetApiSkillSearchMatch {
+    id: string;
+    title: string;
+    task: string;
+    summary: string;
+    steps: string[];
+    verification: string[];
+    files: string[];
+    source: ToolNetApiSkillSource;
+    createdAt: string;
+    score: number;
+}
+export interface ToolNetApiSkillSearch {
+    schema: 'toolnet.api-skill-search.v1';
+    result: {
+        schema: 'toolnet.skill-memory-search.v1';
+        query: string;
+        count: number;
+        matches: ToolNetApiSkillSearchMatch[];
+    };
+}
+export interface ToolNetApiContextOffloadReadInput {
+    assetId: string;
+    maxChars?: number;
+}
+export interface ToolNetApiContextOffloadRead {
+    schema: 'toolnet.api-context-offload.v1';
+    result: {
+        assetId: string;
+        kind: string;
+        bytes: number;
+        truncated: boolean;
+        content: string;
+    };
+}
+export type ToolNetHubRole = 'owner' | 'admin' | 'member' | 'viewer';
+export type ToolNetHubScope = 'hub:read' | 'teams:write' | 'agents:write' | 'acl:manage' | 'loadouts:write' | 'observability:read' | 'wiki:read' | 'wiki:write' | 'governance:read' | 'governance:write';
+export interface ToolNetHubTeam {
+    id: string;
+    name: string;
+    description?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ToolNetHubAgent {
+    id: string;
+    name: string;
+    kind?: string;
+    teamIds: string[];
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ToolNetHubAclGrant {
+    principal: string;
+    role: ToolNetHubRole;
+    scopes: ToolNetHubScope[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ToolNetHubLoadout {
+    agentId: string;
+    tools: string[];
+    memoryMode: 'local' | 'ai';
+    skillMemory: boolean;
+    contextOffload: boolean;
+    maxContextChars: number;
+    updatedAt: string;
+}
+export interface ToolNetHubEvent {
+    id: string;
+    kind: 'request' | 'mutation';
+    action: string;
+    principal: string;
+    ok: boolean;
+    statusCode?: number;
+    durationMs?: number;
+    timestamp: string;
+}
+export interface ToolNetApiHubSummary {
+    schema: 'toolnet.api-hub-summary.v1';
+    hub: {
+        schema: 'toolnet.memory-hub.v1';
+        project: {
+            id: string;
+            name: string;
+            remote: string;
+        };
+        teams: number;
+        agents: number;
+        aclGrants: number;
+        loadouts: number;
+        updatedAt: string;
+    };
+}
+export interface ToolNetApiHubTeams {
+    schema: 'toolnet.api-hub-teams.v1';
+    teams: ToolNetHubTeam[];
+}
+export interface ToolNetApiCreateHubTeamInput {
+    id?: string;
+    name: string;
+    description?: string;
+}
+export interface ToolNetApiHubTeam {
+    schema: 'toolnet.api-hub-team.v1';
+    team: ToolNetHubTeam;
+}
+export interface ToolNetApiHubAgents {
+    schema: 'toolnet.api-hub-agents.v1';
+    agents: ToolNetHubAgent[];
+}
+export interface ToolNetApiCreateHubAgentInput {
+    id?: string;
+    name: string;
+    kind?: string;
+    teamIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ToolNetApiHubAgent {
+    schema: 'toolnet.api-hub-agent.v1';
+    agent: ToolNetHubAgent;
+}
+export interface ToolNetApiHubAcl {
+    schema: 'toolnet.api-hub-acl.v1';
+    grants: ToolNetHubAclGrant[];
+}
+export interface ToolNetApiGrantHubAclInput {
+    principal: string;
+    role: ToolNetHubRole;
+    scopes?: ToolNetHubScope[];
+}
+export interface ToolNetApiHubAclGrant {
+    schema: 'toolnet.api-hub-acl-grant.v1';
+    grant: ToolNetHubAclGrant;
+}
+export interface ToolNetApiHubAclRevoke {
+    schema: 'toolnet.api-hub-acl-revoke.v1';
+    principal: string;
+    revoked: true;
+}
+export interface ToolNetApiHubLoadouts {
+    schema: 'toolnet.api-hub-loadouts.v1';
+    loadouts: ToolNetHubLoadout[];
+}
+export interface ToolNetApiSetHubLoadoutInput {
+    agentId: string;
+    tools?: string[];
+    memoryMode?: 'local' | 'ai';
+    skillMemory?: boolean;
+    contextOffload?: boolean;
+    maxContextChars?: number;
+}
+export interface ToolNetApiHubLoadout {
+    schema: 'toolnet.api-hub-loadout.v1';
+    loadout: ToolNetHubLoadout;
+}
+export interface ToolNetApiHubObservability {
+    schema: 'toolnet.api-hub-observability.v1';
+    observability: {
+        requests: number;
+        mutations: number;
+        errors: number;
+        lastActivityAt?: string;
+        events: ToolNetHubEvent[];
+    };
+}
+export interface ToolNetWikiPage {
+    id: string;
+    slug: string;
+    title: string;
+    summary?: string;
+    content: string;
+    tags: string[];
+    links: string[];
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ToolNetWikiRevision {
+    id: string;
+    pageId: string;
+    slug: string;
+    revision: number;
+    title: string;
+    summary?: string;
+    content: string;
+    tags: string[];
+    links: string[];
+    createdAt: string;
+}
+export interface ToolNetWikiSearchResult {
+    page: ToolNetWikiPage;
+    score: number;
+}
+export interface ToolNetApiWikiSummary {
+    schema: 'toolnet.api-wiki-summary.v1';
+    wiki: {
+        schema: 'toolnet.wiki-summary.v1';
+        projectId: string;
+        pages: number;
+        revisions: number;
+        tags: string[];
+        links: number;
+        orphanPages: number;
+        automatedPages: number;
+        updatedAt: string;
+    };
+}
+export interface ToolNetApiWikiPages {
+    schema: 'toolnet.api-wiki-pages.v1';
+    pages: ToolNetWikiPage[];
+}
+export interface ToolNetApiWikiPage {
+    schema: 'toolnet.api-wiki-page.v1';
+    page: ToolNetWikiPage;
+}
+export interface ToolNetApiCreateWikiPageInput {
+    slug?: string;
+    title: string;
+    summary?: string;
+    content: string;
+    tags?: string[];
+}
+export interface ToolNetApiUpdateWikiPageInput {
+    title?: string;
+    summary?: string;
+    content?: string;
+    tags?: string[];
+}
+export interface ToolNetApiWikiSearch {
+    schema: 'toolnet.api-wiki-search.v1';
+    query: string;
+    results: ToolNetWikiSearchResult[];
+}
+export interface ToolNetApiWikiHistory {
+    schema: 'toolnet.api-wiki-history.v1';
+    revisions: ToolNetWikiRevision[];
+}
+export interface ToolNetApiWikiBacklinks {
+    schema: 'toolnet.api-wiki-backlinks.v1';
+    pages: ToolNetWikiPage[];
+}
+export type ToolNetKnowledgeGovernanceReviewStatus = 'pending' | 'approved' | 'rejected' | 'superseded';
+export type ToolNetKnowledgeGovernanceRisk = 'normal' | 'critical' | 'conflict';
+export interface ToolNetKnowledgeGovernancePolicy {
+    autoApproveThreshold: number;
+    criticalApproveThreshold: number;
+    staleAfterDays: number;
+}
+export interface ToolNetKnowledgeGovernanceReview {
+    id: string;
+    sourceKey: string;
+    sourceType: 'memory' | 'scene' | 'skill';
+    slug: string;
+    digest: string;
+    title: string;
+    summary?: string;
+    content: string;
+    tags: string[];
+    confidence: number;
+    risk: ToolNetKnowledgeGovernanceRisk;
+    reasons: string[];
+    conflicts: string[];
+    status: ToolNetKnowledgeGovernanceReviewStatus;
+    createdAt: string;
+    updatedAt: string;
+    reviewedAt?: string;
+    reviewedBy?: string;
+    reviewNote?: string;
+    appliedAt?: string;
+    supersededBy?: string;
+    mergedInto?: string;
+}
+export interface ToolNetApiGovernanceSummary {
+    schema: 'toolnet.api-governance-summary.v1';
+    governance: {
+        schema: 'toolnet.knowledge-governance-summary.v1';
+        projectId: string;
+        pending: number;
+        approved: number;
+        rejected: number;
+        superseded: number;
+        criticalPending: number;
+        conflictPending: number;
+        auditEvents: number;
+        policy: ToolNetKnowledgeGovernancePolicy;
+        updatedAt: string;
+    };
+}
+export interface ToolNetApiGovernanceReviews {
+    schema: 'toolnet.api-governance-reviews.v1';
+    reviews: ToolNetKnowledgeGovernanceReview[];
+}
+export interface ToolNetApiGovernanceReview {
+    schema: 'toolnet.api-governance-review.v1';
+    review: ToolNetKnowledgeGovernanceReview;
+}
+export interface ToolNetGovernanceDecisionInput {
+    action: 'approve' | 'reject' | 'supersede' | 'merge';
+    note?: string;
+    targetReviewId?: string;
+}
+export interface ToolNetApiKnowledgeQuality {
+    schema: 'toolnet.api-knowledge-quality.v1';
+    quality: {
+        schema: 'toolnet.knowledge-quality.v1';
+        totalPages: number;
+        automatedPages: number;
+        manualPages: number;
+        stalePages: Array<{
+            slug: string;
+            title: string;
+            updatedAt: string;
+            ageDays: number;
+        }>;
+        duplicateTitles: Array<{
+            title: string;
+            pages: string[];
+        }>;
+        pendingReviews: number;
+        lowConfidenceReviews: number;
+        conflicts: number;
+        generatedAt: string;
+    };
+}
+export interface ToolNetApiGovernancePolicy {
+    schema: 'toolnet.api-governance-policy.v1';
+    policy: ToolNetKnowledgeGovernancePolicy;
+}

package/dist/sdk/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolnet-memory",
-  "version": "0.2.21",
+  "version": "0.3.0",
   "description": "Persistent project memory, work continuity, and code intelligence for AI coding agents.",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,7 @@
   "scripts": {
     "dev": "tsx src/index.ts",
     "build": "tsc -p tsconfig.json",
-    "lint": "eslint src tests --ext .ts",
+    "lint": "eslint src tests packages --ext .ts",
     "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\" \"*.md\" \"*.json\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\" \"*.md\" \"*.json\"",
     "typecheck": "tsc --noEmit",
@@ -57,7 +57,7 @@
     "code:visualization:test": "tsx src/code-intelligence/test-visualization.ts",
     "graph:ui": "tsx src/visualization/server.ts",
     "project:status": "tsx src/production/project-status.ts",
-    "build:prod": "npm run build && rm -rf dist/tests dist/visualization/public && mkdir -p dist/visualization/public/vendor && cp src/visualization/public/index.html dist/visualization/public/index.html && cp node_modules/3d-force-graph/dist/3d-force-graph.min.js dist/visualization/public/vendor/3d-force-graph.min.js && find dist -type f \\( -name \"*.bak-*\" -o -name \"*.map\" \\) -delete",
+    "build:prod": "npm run build && npm run build:sdk && rm -rf dist/tests dist/visualization/public && mkdir -p dist/visualization/public/vendor && cp src/visualization/public/index.html dist/visualization/public/index.html && cp node_modules/3d-force-graph/dist/3d-force-graph.min.js dist/visualization/public/vendor/3d-force-graph.min.js && find dist -type f \\( -name \"*.bak-*\" -o -name \"*.map\" \\) -delete",
     "prepack": "npm run build:prod",
     "session:test": "vitest run tests/session/session-core.test.ts",
     "session:opencode:test": "vitest run tests/session/opencode-adapter.test.ts",
@@ -70,7 +70,9 @@
     "semantic-work:test": "vitest run tests/work-continuity/semantic-context.test.ts",
     "context-injection:test": "vitest run tests/work-continuity/context-injection.test.ts",
     "build:bundle": "npm run build && node scripts/build-bundle.mjs",
-    "build:release": "npm run build:prod && node scripts/build-bundle.mjs"
+    "build:release": "npm run build:prod && node scripts/build-bundle.mjs",
+    "api": "tsx src/api/bootstrap.ts",
+    "build:sdk": "tsc -p tsconfig.sdk.json"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1102.0",
@@ -99,9 +101,16 @@
     "bundle",
     "bin/toolnet-memory",
     "README.md",
-    ".env.example"
+    ".env.example",
+    "dist/sdk"
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "exports": {
+    "./sdk": {
+      "types": "./dist/sdk/public.d.ts",
+      "import": "./dist/sdk/public.js"
+    }
   }
 }