gramatr 0.3.0

package/core/migration.ts

@@ -0,0 +1,244 @@
+import { cpSync, existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { buildClaudeHooksFile } from './install.ts';
+
+const MANAGED_EVENTS = [
+  'PreToolUse',
+  'PostToolUse',
+  'UserPromptSubmit',
+  'SessionStart',
+  'SessionEnd',
+  'Stop',
+] as const;
+
+const LEGACY_HOOK_BASENAMES = [
+  'LoadContext.hook.ts',
+  'SecurityValidator.hook.ts',
+  'RatingCapture.hook.ts',
+  'VoiceGate.hook.ts',
+  'AutoWorkCreation.hook.ts',
+  'WorkCompletionLearning.hook.ts',
+  'RelationshipMemory.hook.ts',
+  'SessionSummary.hook.ts',
+  'UpdateCounts.hook.ts',
+  'IntegrityCheck.hook.ts',
+];
+
+export const LEGACY_CLIENT_DIRS = ['aios-v2-client'];
+export const LEGACY_REMOVE_DIRS = ['.claude/hooks'];
+export const LEGACY_REMOVE_HOOK_FILES = LEGACY_HOOK_BASENAMES;
+
+export interface StaleArtifact {
+  kind: 'directory' | 'hook-file';
+  path: string;
+  reason: string;
+}
+
+export interface MigrationOptions {
+  homeDir: string;
+  clientDir: string;
+  includeOptionalUx?: boolean;
+  apply: boolean;
+  log?: (message: string) => void;
+}
+
+interface JsonObject {
+  [key: string]: unknown;
+}
+
+function isRecord(value: unknown): value is JsonObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function commandLooksLegacy(command: string): boolean {
+  if (command.includes('/.claude/hooks/')) return true;
+  if (command.includes('/aios-v2-client/')) return true;
+  return LEGACY_HOOK_BASENAMES.some((basename) => command.includes(`/${basename}`));
+}
+
+function stripLegacyEntriesFromHookEvent(value: unknown): unknown {
+  if (!Array.isArray(value)) return value;
+
+  return value
+    .map((entry) => {
+      if (!isRecord(entry) || !Array.isArray(entry.hooks)) return entry;
+      const hooks = entry.hooks.filter((hook) => {
+        if (!isRecord(hook) || typeof hook.command !== 'string') return true;
+        return !commandLooksLegacy(hook.command);
+      });
+
+      if (hooks.length === 0) return null;
+      return { ...entry, hooks };
+    })
+    .filter(Boolean);
+}
+
+export function sanitizeClaudeSettings(
+  settings: JsonObject,
+  clientDir: string,
+  _includeOptionalUx: boolean = false, // deprecated — thin client has no optional hooks
+): JsonObject {
+  const next = { ...settings };
+  const hooks = isRecord(next.hooks) ? { ...next.hooks } : {};
+
+  for (const [eventName, eventValue] of Object.entries(hooks)) {
+    hooks[eventName] = stripLegacyEntriesFromHookEvent(eventValue);
+  }
+
+  const managed = buildClaudeHooksFile(clientDir).hooks;
+  for (const eventName of MANAGED_EVENTS) {
+    hooks[eventName] = managed[eventName];
+  }
+
+  next.hooks = hooks;
+  return next;
+}
+
+export function sanitizeClaudeJson(claudeJson: JsonObject): JsonObject {
+  if (!isRecord(claudeJson.mcpServers)) return claudeJson;
+  const mcpServers = { ...claudeJson.mcpServers };
+  delete mcpServers.aios;
+  return { ...claudeJson, mcpServers };
+}
+
+export function findStaleArtifacts(
+  homeDir: string,
+  clientDir: string,
+  exists: (path: string) => boolean,
+): StaleArtifact[] {
+  const artifacts: StaleArtifact[] = [];
+
+  for (const dir of LEGACY_CLIENT_DIRS) {
+    const path = `${homeDir}/${dir}`;
+    if (exists(path)) {
+      artifacts.push({
+        kind: 'directory',
+        path,
+        reason: 'Legacy client payload directory',
+      });
+    }
+  }
+
+  for (const dir of LEGACY_REMOVE_DIRS) {
+    const path = `${homeDir}/${dir}`;
+    if (exists(path)) {
+      artifacts.push({
+        kind: 'directory',
+        path,
+        reason: 'Legacy Claude hook directory',
+      });
+    }
+  }
+
+  for (const basename of LEGACY_REMOVE_HOOK_FILES) {
+    const path = `${clientDir}/hooks/${basename}`;
+    if (exists(path)) {
+      artifacts.push({
+        kind: 'hook-file',
+        path,
+        reason: 'Deprecated legacy hook file',
+      });
+    }
+  }
+
+  return artifacts;
+}
+
+function backupFile(path: string, log?: (message: string) => void): void {
+  if (!existsSync(path)) return;
+  const backup = `${path}.backup-${Date.now()}`;
+  cpSync(path, backup);
+  log?.(`OK Backed up ${path} -> ${backup}`);
+}
+
+function readJson(path: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+}
+
+function writeJson(path: string, value: Record<string, unknown>): void {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function removeIfExists(path: string, log?: (message: string) => void): void {
+  if (!existsSync(path)) return;
+  rmSync(path, { recursive: true, force: true });
+  log?.(`OK Removed ${path}`);
+}
+
+function removeLegacyHookFiles(clientDir: string, log?: (message: string) => void): void {
+  const hooksDir = join(clientDir, 'hooks');
+  if (!existsSync(hooksDir)) return;
+
+  for (const basename of LEGACY_REMOVE_HOOK_FILES) {
+    const path = join(hooksDir, basename);
+    if (existsSync(path)) {
+      rmSync(path, { force: true });
+      log?.(`OK Removed stale hook ${path}`);
+    }
+  }
+
+  for (const entry of readdirSync(hooksDir)) {
+    if (!entry.endsWith('.sh')) continue;
+    const path = join(hooksDir, entry);
+    if (statSync(path).isFile()) {
+      rmSync(path, { force: true });
+      log?.(`OK Removed stale shell hook ${path}`);
+    }
+  }
+}
+
+export function runLegacyMigration(options: MigrationOptions): void {
+  const { homeDir, clientDir, includeOptionalUx = false, apply, log } = options;
+  const claudeSettingsPath = join(homeDir, '.claude', 'settings.json');
+  const claudeJsonPath = join(homeDir, '.claude.json');
+
+  log?.('grāmatr legacy install cleanup');
+  log?.(`Mode: ${apply ? 'apply' : 'dry-run'}`);
+  log?.(`Client dir: ${clientDir}`);
+
+  if (existsSync(claudeSettingsPath)) {
+    const sanitized = sanitizeClaudeSettings(readJson(claudeSettingsPath), clientDir, includeOptionalUx);
+    if (apply) {
+      backupFile(claudeSettingsPath, log);
+      writeJson(claudeSettingsPath, sanitized);
+      log?.(`OK Sanitized ${claudeSettingsPath}`);
+    } else {
+      log?.(`Would sanitize ${claudeSettingsPath}`);
+    }
+  }
+
+  if (existsSync(claudeJsonPath)) {
+    const sanitized = sanitizeClaudeJson(readJson(claudeJsonPath));
+    if (apply) {
+      backupFile(claudeJsonPath, log);
+      writeJson(claudeJsonPath, sanitized);
+      log?.(`OK Sanitized ${claudeJsonPath}`);
+    } else {
+      log?.(`Would sanitize ${claudeJsonPath}`);
+    }
+  }
+
+  for (const dir of LEGACY_CLIENT_DIRS) {
+    const path = join(homeDir, dir);
+    if (apply) {
+      removeIfExists(path, log);
+    } else if (existsSync(path)) {
+      log?.(`Would remove ${path}`);
+    }
+  }
+
+  for (const dir of LEGACY_REMOVE_DIRS) {
+    const path = join(homeDir, dir);
+    if (apply) {
+      removeIfExists(path, log);
+    } else if (existsSync(path)) {
+      log?.(`Would remove ${path}`);
+    }
+  }
+
+  if (apply) {
+    removeLegacyHookFiles(clientDir, log);
+  } else if (existsSync(join(clientDir, 'hooks'))) {
+    log?.(`Would remove stale hook files from ${join(clientDir, 'hooks')}`);
+  }
+}

package/core/routing.ts

@@ -0,0 +1,98 @@
+import {
+  callMcpToolDetailed,
+  resolveMcpUrl,
+  saveLastClassification,
+  type MctToolCallError,
+} from '../hooks/lib/gmtr-hook-utils.ts';
+import type { RouteResponse } from './types.ts';
+
+export const MIN_PROMPT_LENGTH = 10;
+export const TRIVIAL_PATTERNS =
+  /^(hi|hey|hello|yo|ok|yes|no|thanks|thank you|sure|yep|nope|k|bye|quit|exit)\b/i;
+
+export function shouldSkipPromptRouting(prompt: string): boolean {
+  const trimmed = prompt.trim();
+  return trimmed.length < MIN_PROMPT_LENGTH || TRIVIAL_PATTERNS.test(trimmed);
+}
+
+export async function routePrompt(options: {
+  prompt: string;
+  projectId?: string;
+  sessionId?: string;
+  timeoutMs?: number;
+}): Promise<{ route: RouteResponse | null; error: MctToolCallError | null }> {
+  const result = await callMcpToolDetailed<RouteResponse>(
+    'gmtr_route_request',
+    {
+      prompt: options.prompt,
+      ...(options.projectId ? { project_id: options.projectId } : {}),
+      ...(options.sessionId ? { session_id: options.sessionId } : {}),
+    },
+    options.timeoutMs ?? 15000,
+  );
+
+  return {
+    route: result.data,
+    error: result.error,
+  };
+}
+
+export function describeRoutingFailure(error: MctToolCallError): {
+  title: string;
+  detail: string;
+  action: string;
+} {
+  switch (error.reason) {
+    case 'auth':
+      return {
+        title: 'Routing request failed due to authentication.',
+        detail: error.detail,
+        action: 'Check the configured GMTR token for the hook runtime.',
+      };
+    case 'timeout':
+      return {
+        title: 'Routing request timed out.',
+        detail: error.detail,
+        action: 'Check gramatr server latency or increase the hook timeout.',
+      };
+    case 'network_error':
+      return {
+        title: 'Routing request could not reach the gramatr MCP endpoint.',
+        detail: error.detail,
+        action: `Verify connectivity to ${resolveMcpUrl()}.`,
+      };
+    case 'http_error':
+    case 'mcp_error':
+    case 'parse_error':
+    case 'unknown':
+    default:
+      return {
+        title: 'Routing request failed before intelligence could be injected.',
+        detail: error.detail,
+        action: `Inspect the response from ${resolveMcpUrl()} and the gmtr_route_request handler.`,
+      };
+  }
+}
+
+export function persistClassificationResult(options: {
+  rootDir: string;
+  prompt: string;
+  route: RouteResponse | null;
+  downstreamModel: string | null;
+  clientType: string;
+  agentName: string;
+}): void {
+  saveLastClassification(options.rootDir, {
+    timestamp: new Date().toISOString(),
+    original_prompt: options.prompt,
+    effort_level: options.route?.classification?.effort_level || null,
+    intent_type: options.route?.classification?.intent_type || null,
+    confidence: options.route?.classification?.confidence ?? null,
+    classifier_model: options.route?.execution_summary?.qwen_model || null,
+    downstream_model: options.downstreamModel || null,
+    client_type: options.clientType,
+    agent_name: options.agentName,
+    pending_feedback: true,
+    feedback_submitted_at: null,
+  });
+}

package/core/session.ts

@@ -0,0 +1,202 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { basename, join } from 'path';
+import {
+  callMcpTool,
+  createDefaultConfig,
+  deriveProjectId,
+  type GitContext,
+  type GmtrConfig,
+  migrateConfig,
+  now,
+  readGmtrConfig,
+  writeGmtrConfig,
+} from '../hooks/lib/gmtr-hook-utils.ts';
+import type { HandoffResponse, SessionStartResponse } from './types.ts';
+
+export interface PreparedProjectSession {
+  projectId: string;
+  config: GmtrConfig;
+  projectEntityId: string | null;
+  restoreNeeded: boolean;
+  hasRestoreContext: boolean;
+  created: boolean;
+}
+
+export interface CurrentProjectContextPayload {
+  type: 'git_project' | 'non_git';
+  session_id: string;
+  project_name: string;
+  working_directory: string;
+  session_start: string;
+  gmtr_config_path: string;
+  project_entity_id: string | null;
+  action_required: string;
+  project_id?: string;
+  git_root?: string;
+  git_branch?: string;
+  git_commit?: string;
+  git_remote?: string;
+  restore_needed?: boolean;
+}
+
+export function normalizeSessionStartResponse(
+  response: SessionStartResponse | null | undefined,
+): {
+  interactionId: string | null;
+  entityId: string | null;
+  resumed: boolean;
+  handoffContext: string | null;
+} {
+  return {
+    interactionId: response?.interaction_id || response?.interactionId || null,
+    entityId: response?.entity_id || response?.entityId || null,
+    resumed: response?.interaction_resumed === true || response?.interactionResumed === true,
+    handoffContext: response?.handoff_context || response?.handoffContext || null,
+  };
+}
+
+export function prepareProjectSessionState(options: {
+  git: GitContext;
+  sessionId: string;
+  transcriptPath: string;
+}): PreparedProjectSession {
+  const { git, sessionId, transcriptPath } = options;
+  const projectId = deriveProjectId(git.remote, git.projectName);
+  const timestamp = now();
+
+  let config = readGmtrConfig(git.root);
+  let created = false;
+
+  if (config) {
+    config = migrateConfig(config, projectId);
+    config.last_session_id = sessionId;
+    config.project_id = projectId;
+    config.current_session = {
+      ...config.current_session,
+      session_id: sessionId,
+      transcript_path: transcriptPath,
+      last_updated: timestamp,
+      token_limit: 200000,
+    };
+    config.continuity_stats = config.continuity_stats || {};
+    config.continuity_stats.total_sessions = (config.continuity_stats.total_sessions || 0) + 1;
+    config.metadata = config.metadata || {};
+    config.metadata.updated = timestamp;
+  } else {
+    config = createDefaultConfig({
+      projectId,
+      projectName: git.projectName,
+      gitRemote: git.remote,
+      sessionId,
+      transcriptPath,
+    });
+    created = true;
+  }
+
+  writeGmtrConfig(git.root, config);
+
+  return {
+    projectId,
+    config,
+    projectEntityId: config.project_entity_id || null,
+    restoreNeeded: config.last_compact?.timestamp != null,
+    hasRestoreContext: config.last_compact?.summary != null,
+    created,
+  };
+}
+
+export async function startRemoteSession(options: {
+  clientType: string;
+  sessionId?: string;
+  projectId: string;
+  projectName?: string;
+  gitRemote: string;
+  directory: string;
+}): Promise<SessionStartResponse | null> {
+  return (await callMcpTool(
+    'gmtr_session_start',
+    {
+      client_type: options.clientType,
+      project_id: options.projectId,
+      ...(options.projectName ? { project_name: options.projectName } : {}),
+      git_remote: options.gitRemote,
+      directory: options.directory,
+      ...(options.sessionId ? { session_id: options.sessionId } : {}),
+    },
+    15000,
+  )) as SessionStartResponse | null;
+}
+
+export async function loadProjectHandoff(projectId: string): Promise<HandoffResponse | null> {
+  return (await callMcpTool(
+    'gmtr_load_handoff',
+    { project_id: projectId },
+    15000,
+  )) as HandoffResponse | null;
+}
+
+export function persistSessionRegistration(rootDir: string, response: SessionStartResponse | null): GmtrConfig | null {
+  const normalized = normalizeSessionStartResponse(response);
+  if (!normalized.interactionId && !normalized.entityId) return readGmtrConfig(rootDir);
+
+  const config = readGmtrConfig(rootDir);
+  if (!config) return null;
+  config.current_session = config.current_session || {};
+  if (normalized.interactionId) config.current_session.interaction_id = normalized.interactionId;
+  if (normalized.entityId) config.current_session.gmtr_entity_id = normalized.entityId;
+  writeGmtrConfig(rootDir, config);
+  return config;
+}
+
+export function writeCurrentProjectContextFile(payload: CurrentProjectContextPayload): void {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const claudeDir = join(home, '.claude');
+  if (!existsSync(claudeDir)) mkdirSync(claudeDir, { recursive: true });
+  const contextFile = join(claudeDir, 'current-project-context.json');
+  writeFileSync(contextFile, JSON.stringify(payload, null, 2) + '\n');
+}
+
+export function buildGitProjectContextPayload(options: {
+  git: GitContext;
+  sessionId: string;
+  workingDirectory: string;
+  sessionStart: string;
+  projectId: string;
+  projectEntityId: string | null;
+  restoreNeeded: boolean;
+}): CurrentProjectContextPayload {
+  return {
+    type: 'git_project',
+    session_id: options.sessionId,
+    project_name: options.git.projectName,
+    project_id: options.projectId,
+    git_root: options.git.root,
+    git_branch: options.git.branch,
+    git_commit: options.git.commit,
+    git_remote: options.git.remote,
+    working_directory: options.workingDirectory,
+    session_start: options.sessionStart,
+    gmtr_config_path: join(options.git.root, '.gmtr', 'settings.json'),
+    project_entity_id: options.projectEntityId,
+    restore_needed: options.restoreNeeded,
+    action_required: 'check_or_create_project_entity',
+  };
+}
+
+export function buildNonGitProjectContextPayload(options: {
+  cwd: string;
+  sessionId: string;
+  sessionStart: string;
+  projectEntityId: string | null;
+}): CurrentProjectContextPayload {
+  return {
+    type: 'non_git',
+    session_id: options.sessionId,
+    project_name: basename(options.cwd),
+    working_directory: options.cwd,
+    session_start: options.sessionStart,
+    gmtr_config_path: join(options.cwd, '.gmtr', 'settings.json'),
+    project_entity_id: options.projectEntityId,
+    action_required: 'gmtr_init_needed',
+  };
+}