@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.4

package/packages/agentsam-repository/src/tickets.js

@@ -0,0 +1,184 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+function sqlEsc(value) {
+  return String(value ?? '').replaceAll("'", "''");
+}
+
+function sqlText(value) {
+  return value == null || value === '' ? 'NULL' : `'${sqlEsc(value)}'`;
+}
+
+function sqlInt(value) {
+  return value == null || value === '' || !Number.isFinite(Number(value))
+    ? 'NULL'
+    : String(Math.trunc(Number(value)));
+}
+
+export function createAgentRunId() {
+  return `arun_${crypto.randomUUID().replace(/-/g, '').slice(0, 16)}`;
+}
+
+export function createTicketId() {
+  return `tkt_${crypto.randomUUID().replace(/-/g, '').slice(0, 16)}`;
+}
+
+/**
+ * Generate SQL for ticket creation with mandatory agentsam_agent_run when active.
+ */
+export function generateTicketCreateSql({
+  accountId,
+  ticketId = createTicketId(),
+  title,
+  description = null,
+  status = 'active',
+  statusReason = null,
+  project = 'inneranimalmedia',
+  subsystem = null,
+  priority = 'P2',
+  docPath = null,
+  surface = 'platform',
+  accountIdForTicket = accountId,
+  repositoryId = null,
+  ownerRef = null,
+  source = 'agentsam_sdk',
+  dedupKey = null,
+  now = Math.floor(Date.now() / 1000),
+  agentRunId = null,
+}) {
+  const account = clean(accountId);
+  if (!account) throw new Error('account_id_required');
+  const tTitle = clean(title);
+  if (!tTitle) throw new Error('title_required');
+
+  const statements = [];
+  let runId = clean(agentRunId);
+
+  if (status === 'active' && !runId) {
+    runId = createAgentRunId();
+    statements.push(`INSERT INTO agentsam_agent_run (
+  id, account_id, mode, status, started_at_unix, created_at_unix, updated_at_unix
+) VALUES (
+  ${sqlText(runId)}, ${sqlText(account)}, 'agent', 'running', ${sqlInt(now)}, ${sqlInt(now)}, ${sqlInt(now)}
+);`);
+  }
+
+  statements.push(`INSERT INTO agentsam_tickets (
+  id, title, description, status, status_reason, project, subsystem,
+  priority, doc_path, surface, dedup_key, agent_run_id, owner_ref, source,
+  account_id, repository_id, created_at, updated_at, closed_at
+) VALUES (
+  ${sqlText(ticketId)}, ${sqlText(tTitle.slice(0, 240))}, ${sqlText(description)}, ${sqlText(status)},
+  ${sqlText(statusReason)}, ${sqlText(project)}, ${sqlText(subsystem)}, ${sqlText(priority)},
+  ${sqlText(docPath)}, ${sqlText(surface)}, ${sqlText(dedupKey)}, ${sqlText(runId || null)},
+  ${sqlText(ownerRef)}, ${sqlText(source)},
+  ${sqlText(accountIdForTicket)}, ${sqlText(repositoryId)},
+  ${sqlInt(now)}, ${sqlInt(now)}, ${status === 'shipped' || status === 'abandoned' ? sqlInt(now) : 'NULL'}
+);`);
+
+  statements.push(`INSERT INTO agentsam_ticket_events (
+  id, ticket_id, event_type, from_status, to_status, detail, actor_type, created_at
+) VALUES (
+  'tke_' || lower(hex(randomblob(8))), ${sqlText(ticketId)}, 'status_change', NULL, ${sqlText(status)},
+  'created', 'agentsam_sdk', ${sqlInt(now)}
+);`);
+
+  return {
+    sql: statements.join('\n\n'),
+    ticketId,
+    agentRunId: runId || null,
+  };
+}
+
+/**
+ * Generate SQL to activate a ticket and wire a real agentsam_agent_run row.
+ */
+export function generateTicketActivationSql({
+  accountId,
+  ticketId,
+  agentRunId = createAgentRunId(),
+  statusReason = null,
+  now = Math.floor(Date.now() / 1000),
+}) {
+  const account = clean(accountId);
+  const tid = clean(ticketId);
+  if (!account) throw new Error('account_id_required');
+  if (!tid) throw new Error('ticket_id_required');
+  const runId = clean(agentRunId) || createAgentRunId();
+
+  const statements = [
+    `INSERT INTO agentsam_agent_run (
+  id, account_id, mode, status, started_at_unix, created_at_unix, updated_at_unix
+) VALUES (
+  ${sqlText(runId)}, ${sqlText(account)}, 'agent', 'running', ${sqlInt(now)}, ${sqlInt(now)}, ${sqlInt(now)}
+);`,
+    `UPDATE agentsam_tickets SET
+  status = 'active',
+  status_reason = ${sqlText(statusReason)},
+  agent_run_id = COALESCE(agent_run_id, ${sqlText(runId)}),
+  updated_at = ${sqlInt(now)},
+  closed_at = NULL
+WHERE id = ${sqlText(tid)};`,
+    `INSERT INTO agentsam_ticket_events (
+  id, ticket_id, event_type, from_status, to_status, detail, actor_type, created_at
+) VALUES (
+  'tke_' || lower(hex(randomblob(8))), ${sqlText(tid)}, 'status_change', 'backlog', 'active',
+  'activated_with_agent_run', 'agentsam_sdk', ${sqlInt(now)}
+);`,
+  ];
+
+  return {
+    sql: statements.join('\n\n'),
+    ticketId: tid,
+    agentRunId: runId,
+  };
+}
+
+/**
+ * Generate SQL to close a ticket (shipped/blocked/abandoned) and finish its agent run.
+ */
+export function generateTicketCloseSql({
+  ticketId,
+  status = 'shipped',
+  statusReason = null,
+  linkedCommit = null,
+  now = Math.floor(Date.now() / 1000),
+}) {
+  const tid = clean(ticketId);
+  if (!tid) throw new Error('ticket_id_required');
+  const runStatus = status === 'abandoned' || status === 'blocked' ? 'failed' : 'completed';
+
+  const statements = [
+    `UPDATE agentsam_tickets SET
+  status = ${sqlText(status)},
+  status_reason = ${sqlText(statusReason)},
+  linked_commit = COALESCE(${sqlText(linkedCommit)}, linked_commit),
+  closed_at = ${status === 'shipped' || status === 'abandoned' ? sqlInt(now) : 'closed_at'},
+  updated_at = ${sqlInt(now)}
+WHERE id = ${sqlText(tid)};`,
+    `UPDATE agentsam_agent_run SET
+  status = ${sqlText(runStatus)},
+  completed_at_unix = ${sqlInt(now)},
+  updated_at_unix = ${sqlInt(now)}
+WHERE id = (SELECT agent_run_id FROM agentsam_tickets WHERE id = ${sqlText(tid)})
+  AND status = 'running';`,
+    `INSERT INTO agentsam_ticket_events (
+  id, ticket_id, event_type, from_status, to_status, detail, commit_sha, actor_type, created_at
+) VALUES (
+  'tke_' || lower(hex(randomblob(8))), ${sqlText(tid)}, 'status_change', 'active', ${sqlText(status)},
+  ${sqlText(statusReason || `marked_${status}`)}, ${sqlText(linkedCommit)}, 'agentsam_sdk', ${sqlInt(now)}
+);`,
+  ];
+
+  return {
+    sql: statements.join('\n\n'),
+    ticketId: tid,
+  };
+}

package/packages/agentsam-repository/src/work-tracking.js

@@ -0,0 +1,199 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { resolveGitContext, tryResolveGitContext } from './git-context.js';
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+function sqlEsc(value) {
+  return String(value ?? '').replaceAll("'", "''");
+}
+
+function sqlText(value) {
+  return value == null || value === '' ? 'NULL' : `'${sqlEsc(value)}'`;
+}
+
+function sqlInt(value) {
+  return value == null || value === '' || !Number.isFinite(Number(value))
+    ? 'NULL'
+    : String(Math.trunc(Number(value)));
+}
+
+/**
+ * Scan git commits from a repository root.
+ * Returns array of { sha, message, author_name, author_email, committed_at }.
+ */
+export function scanGitCommits(cwd = process.cwd(), { limit = 50, sinceSha = null } = {}) {
+  const args = ['log', `-n${Math.max(1, limit)}`, '--format=%H%x1f%s%x1f%an%x1f%ae%x1f%at'];
+  if (sinceSha) {
+    args.splice(1, 0, `${sinceSha}..HEAD`);
+  }
+  try {
+    const raw = execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const lines = raw.trim().split(/\r?\n/).filter(Boolean);
+    const commits = [];
+    for (const line of lines) {
+      const parts = line.split('\x1f');
+      if (parts.length >= 5) {
+        commits.push({
+          sha: clean(parts[0]),
+          message: clean(parts[1]),
+          author_name: clean(parts[2]),
+          author_email: clean(parts[3]),
+          committed_at: Number(parts[4]) || Math.floor(Date.now() / 1000),
+        });
+      }
+    }
+    return commits;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Generate idempotent SQL to insert commits and advance the tracking checkpoint.
+ */
+export function generateGitCommitIngestSql({
+  accountId,
+  repositoryId,
+  commits = [],
+  trackerKey = 'git_commit_ingest',
+  branch = 'main',
+  ticketId = null,
+}) {
+  const account = clean(accountId);
+  const repository = clean(repositoryId);
+  if (!account) throw new Error('account_id_required');
+  if (!repository) throw new Error('repository_id_required');
+
+  const statements = [];
+
+  for (const c of commits) {
+    if (!c.sha) continue;
+    statements.push(`INSERT OR IGNORE INTO agentsam_work_git_commits (
+  id, account_id, repository_id, sha, message, author_name, author_email, committed_at, captured_at
+) VALUES (
+  'wgc_' || lower(hex(randomblob(8))),
+  ${sqlText(account)},
+  ${sqlText(repository)},
+  ${sqlText(c.sha)},
+  ${sqlText(c.message)},
+  ${sqlText(c.author_name)},
+  ${sqlText(c.author_email)},
+  ${sqlInt(c.committed_at)},
+  unixepoch()
+);`);
+  }
+
+  if (commits.length > 0) {
+    const latestSha = commits[0].sha;
+    const cursor = JSON.stringify({
+      last_sha: latestSha,
+      branch: branch || 'main',
+      ingested_count: commits.length,
+      updated_at: Math.floor(Date.now() / 1000),
+    });
+
+    statements.push(`INSERT INTO agentsam_work_tracking_checkpoint (
+  account_id, repository_id, tracker_key, last_run_at, cursor_json, updated_at
+) VALUES (
+  ${sqlText(account)},
+  ${sqlText(repository)},
+  ${sqlText(trackerKey)},
+  unixepoch(),
+  ${sqlText(cursor)},
+  unixepoch()
+)
+ON CONFLICT(account_id, repository_id, tracker_key) DO UPDATE SET
+  last_run_at = excluded.last_run_at,
+  cursor_json = excluded.cursor_json,
+  updated_at = excluded.updated_at;`);
+
+    // Wire git observation to active tickets
+    statements.push(`UPDATE agentsam_tickets
+SET linked_commit = ${sqlText(latestSha)}, updated_at = unixepoch()
+WHERE (${sqlText(ticketId)} IS NOT NULL AND id = ${sqlText(ticketId)})
+   OR (status = 'active' AND (linked_commit IS NULL OR linked_commit = '') AND (
+     id = (SELECT current_task_id FROM agentsam_workspace_state WHERE repository_id = ${sqlText(repository)} AND current_task_id IS NOT NULL)
+     OR project = 'inneranimalmedia'
+   ));`);
+
+    statements.push(`INSERT INTO agentsam_ticket_events (
+  id, ticket_id, event_type, commit_sha, detail, actor_type, created_at
+) SELECT
+  'tke_' || lower(hex(randomblob(8))),
+  id,
+  'commit_linked',
+  ${sqlText(latestSha)},
+  'git observation linked commit ' || ${sqlText(latestSha)},
+  'agentsam_git_observation',
+  unixepoch()
+FROM agentsam_tickets
+WHERE linked_commit = ${sqlText(latestSha)}
+  AND updated_at >= unixepoch() - 2;`);
+  }
+
+  return statements.join('\n\n');
+}
+
+/**
+ * Sync git commits for a local repo checkout to Cloudflare D1.
+ */
+export async function syncGitCommitsToD1({
+  cwd = process.cwd(),
+  accountId,
+  repositoryId,
+  ticketId = null,
+  wranglerConfig = 'apps/local-studio/backend/wrangler.jsonc',
+  databaseName = 'inneranimalmedia-business',
+  limit = 25,
+  trackerKey = 'git_commit_ingest',
+} = {}) {
+  const git = tryResolveGitContext({ cwd });
+  const repoId = repositoryId || (git?.repoFullName ? `github:${git.repoFullName.toLowerCase()}` : null);
+  if (!repoId) throw new Error('repository_identity_unresolved');
+  if (!accountId) throw new Error('account_id_required');
+
+  const commits = scanGitCommits(cwd, { limit });
+  if (!commits.length) {
+    return { ok: true, ingested: 0, latest_sha: null };
+  }
+
+  const sql = generateGitCommitIngestSql({
+    accountId,
+    repositoryId: repoId,
+    commits,
+    trackerKey,
+    branch: git?.branch || 'main',
+    ticketId,
+  });
+
+  const tmpFile = path.join(os.tmpdir(), `agentsam-commit-sync-${Date.now()}.sql`);
+  fs.writeFileSync(tmpFile, `${sql}\n`, 'utf8');
+
+  try {
+    const configPath = path.resolve(wranglerConfig);
+    const args = ['d1', 'execute', databaseName, '--remote', '--yes', `--file=${tmpFile}`];
+    if (fs.existsSync(configPath)) {
+      args.push('--config', configPath);
+    }
+    execFileSync('npx', ['wrangler', ...args], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return {
+      ok: true,
+      ingested: commits.length,
+      latest_sha: commits[0].sha,
+      repository_id: repoId,
+    };
+  } finally {
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+  }
+}

package/packages/agentsam-repository/src/workspace-state.js

@@ -0,0 +1,176 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { tryResolveGitContext } from './git-context.js';
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+function sqlEsc(value) {
+  return String(value ?? '').replaceAll("'", "''");
+}
+
+function sqlText(value) {
+  return value == null || value === '' ? 'NULL' : `'${sqlEsc(value)}'`;
+}
+
+function sqlInt(value) {
+  return value == null || value === '' || !Number.isFinite(Number(value))
+    ? 'NULL'
+    : String(Math.trunc(Number(value)));
+}
+
+/**
+ * Generate idempotent SQL to upsert workspace state keyed on repository_id (singleton per repo).
+ */
+export function generateWorkspaceStateUpsertSql({
+  repositoryId,
+  workspaceId = null,
+  currentTaskId = null,
+  lockedBy = null,
+  checkpointSha = null,
+  checkpointLabel = null,
+  activeFile = null,
+  lastAgentAction = null,
+  stateJson = '{}',
+  now = Math.floor(Date.now() / 1000),
+}) {
+  const repoId = clean(repositoryId);
+  if (!repoId) throw new Error('repository_id_required');
+
+  const wsId = clean(workspaceId) || `ws_${repoId.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+  const taskId = clean(currentTaskId) || null;
+  const locker = clean(lockedBy) || null;
+  const sha = clean(checkpointSha) || null;
+  const label = clean(checkpointLabel) || null;
+  const file = clean(activeFile) || null;
+  const action = clean(lastAgentAction) || null;
+  const state = typeof stateJson === 'string' ? stateJson : JSON.stringify(stateJson || {});
+
+  const insertSql = `INSERT INTO agentsam_workspace_state (
+  id, repository_id, workspace_id, current_task_id, locked_by, checkpoint_sha,
+  checkpoint_label, active_file, last_agent_action, state_json, created_at, updated_at
+) VALUES (
+  'wss_' || lower(hex(randomblob(8))),
+  ${sqlText(repoId)},
+  ${sqlText(wsId)},
+  ${sqlText(taskId)},
+  ${sqlText(locker)},
+  ${sqlText(sha)},
+  ${sqlText(label)},
+  ${sqlText(file)},
+  ${sqlText(action)},
+  ${sqlText(state)},
+  ${sqlInt(now)},
+  ${sqlInt(now)}
+)
+ON CONFLICT(repository_id) DO UPDATE SET
+  current_task_id = COALESCE(excluded.current_task_id, agentsam_workspace_state.current_task_id),
+  locked_by = COALESCE(excluded.locked_by, agentsam_workspace_state.locked_by),
+  checkpoint_sha = COALESCE(excluded.checkpoint_sha, agentsam_workspace_state.checkpoint_sha),
+  checkpoint_label = COALESCE(excluded.checkpoint_label, agentsam_workspace_state.checkpoint_label),
+  active_file = COALESCE(excluded.active_file, agentsam_workspace_state.active_file),
+  last_agent_action = COALESCE(excluded.last_agent_action, agentsam_workspace_state.last_agent_action),
+  state_json = CASE WHEN excluded.state_json != '{}' THEN excluded.state_json ELSE agentsam_workspace_state.state_json END,
+  updated_at = excluded.updated_at;`;
+
+  return insertSql;
+}
+
+/**
+ * Read workspace state from D1 for a repository.
+ */
+export async function readWorkspaceStateFromD1({
+  cwd = process.cwd(),
+  repositoryId = null,
+  wranglerConfig = 'apps/local-studio/backend/wrangler.jsonc',
+  databaseName = 'inneranimalmedia-business',
+} = {}) {
+  const git = tryResolveGitContext({ cwd });
+  const repoId = repositoryId || (git?.repoFullName ? `github:${git.repoFullName.toLowerCase()}` : null);
+  if (!repoId) return null;
+
+  try {
+    const configPath = path.resolve(wranglerConfig);
+    const args = [
+      'd1', 'execute', databaseName, '--remote', '--json',
+      `--command=SELECT * FROM agentsam_workspace_state WHERE repository_id = '${sqlEsc(repoId)}' LIMIT 1;`,
+    ];
+    if (fs.existsSync(configPath)) {
+      args.push('--config', configPath);
+    }
+    const out = execFileSync('npx', ['wrangler', ...args], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const parsed = JSON.parse(out);
+    const rows = parsed?.[0]?.results;
+    return rows && rows.length > 0 ? rows[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Sync workspace state beliefs to Cloudflare D1.
+ */
+export async function syncWorkspaceStateToD1({
+  cwd = process.cwd(),
+  repositoryId = null,
+  workspaceId = null,
+  currentTaskId = null,
+  lockedBy = 'agentsam_cli',
+  checkpointSha = null,
+  checkpointLabel = null,
+  activeFile = null,
+  lastAgentAction = null,
+  stateJson = '{}',
+  wranglerConfig = 'apps/local-studio/backend/wrangler.jsonc',
+  databaseName = 'inneranimalmedia-business',
+} = {}) {
+  const git = tryResolveGitContext({ cwd });
+  const repoId = repositoryId || (git?.repoFullName ? `github:${git.repoFullName.toLowerCase()}` : null);
+  if (!repoId) throw new Error('repository_identity_unresolved');
+
+  const sha = checkpointSha || git?.headSha || null;
+  const sql = generateWorkspaceStateUpsertSql({
+    repositoryId: repoId,
+    workspaceId,
+    currentTaskId,
+    lockedBy,
+    checkpointSha: sha,
+    checkpointLabel,
+    activeFile,
+    lastAgentAction,
+    stateJson,
+  });
+
+  const tmpFile = path.join(os.tmpdir(), `agentsam-ws-sync-${Date.now()}.sql`);
+  fs.writeFileSync(tmpFile, `${sql}\n`, 'utf8');
+
+  try {
+    const configPath = path.resolve(wranglerConfig);
+    const args = ['d1', 'execute', databaseName, '--remote', '--yes', `--file=${tmpFile}`];
+    if (fs.existsSync(configPath)) {
+      args.push('--config', configPath);
+    }
+    execFileSync('npx', ['wrangler', ...args], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return {
+      ok: true,
+      repository_id: repoId,
+      current_task_id: currentTaskId,
+      checkpoint_sha: sha,
+    };
+  } finally {
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+  }
+}