@enbox/gitd 0.0.1

package/src/cli/commands/social.ts

@@ -0,0 +1,221 @@
+/**
+ * `gitd social` — stars, follows, and activity feeds.
+ *
+ * Stars and follows live on the actor's DWN (data sovereignty).
+ * Aggregate counts require an indexer.
+ *
+ * Usage:
+ *   gitd star <did>                         Star a repo (by owner DID)
+ *   gitd unstar <did>                       Remove a star
+ *   gitd stars                              List starred repos
+ *   gitd follow <did>                       Follow a user
+ *   gitd unfollow <did>                     Unfollow a user
+ *   gitd following                          List followed users
+ *
+ * @module
+ */
+
+import type { AgentContext } from '../agent.js';
+
+// ---------------------------------------------------------------------------
+// Sub-command dispatch
+// ---------------------------------------------------------------------------
+
+export async function socialCommand(ctx: AgentContext, args: string[]): Promise<void> {
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  switch (sub) {
+    case 'star': return starRepo(ctx, rest);
+    case 'unstar': return unstarRepo(ctx, rest);
+    case 'stars': return listStars(ctx);
+    case 'follow': return followUser(ctx, rest);
+    case 'unfollow': return unfollowUser(ctx, rest);
+    case 'following': return listFollowing(ctx);
+    default:
+      console.error('Usage: gitd social <star|unstar|stars|follow|unfollow|following>');
+      process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// star
+// ---------------------------------------------------------------------------
+
+async function starRepo(ctx: AgentContext, args: string[]): Promise<void> {
+  const repoDid = args[0];
+  if (!repoDid) {
+    console.error('Usage: gitd social star <repo-owner-did>');
+    process.exit(1);
+  }
+
+  // Query the target DID's DWN for their repo record.
+  // Use `from` to route the query to the remote DWN when the target
+  // differs from the local agent.
+  const from = repoDid === ctx.did ? undefined : repoDid;
+  const { records: repoRecords } = await ctx.repo.records.query('repo', { from });
+
+  if (repoRecords.length === 0) {
+    console.error(`No repository found for ${repoDid}.`);
+    process.exit(1);
+  }
+
+  const repoRecord = repoRecords[0];
+  const repoRecordId = repoRecord.id;
+  const repoData = await repoRecord.data.json();
+  const repoName = repoData.name ?? undefined;
+
+  // Check if already starred.
+  const { records: existing } = await ctx.social.records.query('star', {
+    filter: { tags: { repoDid } },
+  });
+
+  if (existing.length > 0) {
+    console.log(`Already starred ${repoDid}.`);
+    return;
+  }
+
+  const { status } = await ctx.social.records.create('star', {
+    data : { repoDid, repoRecordId, repoName },
+    tags : { repoDid, repoRecordId },
+  });
+
+  if (status.code >= 300) {
+    console.error(`Failed to star repo: ${status.code} ${status.detail}`);
+    process.exit(1);
+  }
+
+  console.log(`Starred ${repoDid}${repoName ? ` (${repoName})` : ''}.`);
+}
+
+// ---------------------------------------------------------------------------
+// unstar
+// ---------------------------------------------------------------------------
+
+async function unstarRepo(ctx: AgentContext, args: string[]): Promise<void> {
+  const repoDid = args[0];
+  if (!repoDid) {
+    console.error('Usage: gitd social unstar <repo-owner-did>');
+    process.exit(1);
+  }
+
+  const { records } = await ctx.social.records.query('star', {
+    filter: { tags: { repoDid } },
+  });
+
+  if (records.length === 0) {
+    console.error(`No star found for ${repoDid}.`);
+    process.exit(1);
+  }
+
+  const { status } = await records[0].delete();
+  if (status.code >= 300) {
+    console.error(`Failed to unstar: ${status.code} ${status.detail}`);
+    process.exit(1);
+  }
+
+  console.log(`Unstarred ${repoDid}.`);
+}
+
+// ---------------------------------------------------------------------------
+// stars
+// ---------------------------------------------------------------------------
+
+async function listStars(ctx: AgentContext): Promise<void> {
+  const { records } = await ctx.social.records.query('star');
+
+  if (records.length === 0) {
+    console.log('No starred repos.');
+    return;
+  }
+
+  console.log(`Starred repos (${records.length}):\n`);
+  for (const rec of records) {
+    const data = await rec.data.json();
+    const date = rec.dateCreated?.slice(0, 10) ?? '';
+    console.log(`  ${data.repoDid}${data.repoName ? ` (${data.repoName})` : ''}  ${date}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// follow
+// ---------------------------------------------------------------------------
+
+async function followUser(ctx: AgentContext, args: string[]): Promise<void> {
+  const targetDid = args[0];
+  if (!targetDid) {
+    console.error('Usage: gitd social follow <did>');
+    process.exit(1);
+  }
+
+  // Check if already following.
+  const { records: existing } = await ctx.social.records.query('follow', {
+    filter: { tags: { targetDid } },
+  });
+
+  if (existing.length > 0) {
+    console.log(`Already following ${targetDid}.`);
+    return;
+  }
+
+  const { status } = await ctx.social.records.create('follow', {
+    data : { targetDid },
+    tags : { targetDid },
+  });
+
+  if (status.code >= 300) {
+    console.error(`Failed to follow: ${status.code} ${status.detail}`);
+    process.exit(1);
+  }
+
+  console.log(`Following ${targetDid}.`);
+}
+
+// ---------------------------------------------------------------------------
+// unfollow
+// ---------------------------------------------------------------------------
+
+async function unfollowUser(ctx: AgentContext, args: string[]): Promise<void> {
+  const targetDid = args[0];
+  if (!targetDid) {
+    console.error('Usage: gitd social unfollow <did>');
+    process.exit(1);
+  }
+
+  const { records } = await ctx.social.records.query('follow', {
+    filter: { tags: { targetDid } },
+  });
+
+  if (records.length === 0) {
+    console.error(`Not following ${targetDid}.`);
+    process.exit(1);
+  }
+
+  const { status } = await records[0].delete();
+  if (status.code >= 300) {
+    console.error(`Failed to unfollow: ${status.code} ${status.detail}`);
+    process.exit(1);
+  }
+
+  console.log(`Unfollowed ${targetDid}.`);
+}
+
+// ---------------------------------------------------------------------------
+// following
+// ---------------------------------------------------------------------------
+
+async function listFollowing(ctx: AgentContext): Promise<void> {
+  const { records } = await ctx.social.records.query('follow');
+
+  if (records.length === 0) {
+    console.log('Not following anyone.');
+    return;
+  }
+
+  console.log(`Following (${records.length}):\n`);
+  for (const rec of records) {
+    const data = await rec.data.json();
+    const date = rec.dateCreated?.slice(0, 10) ?? '';
+    console.log(`  ${data.targetDid}${data.alias ? ` (${data.alias})` : ''}  ${date}`);
+  }
+}

package/src/cli/commands/web.ts

@@ -0,0 +1,30 @@
+/**
+ * `gitd web` — start the read-only web UI server.
+ *
+ * Usage:
+ *   gitd web [--port <port>]
+ *
+ * Serves a read-only HTML interface for browsing repo metadata, issues,
+ * patches, releases, and wiki pages.  Default port: 8080.
+ *
+ * @module
+ */
+
+import type { AgentContext } from '../agent.js';
+
+import { flagValue } from '../flags.js';
+import { startWebServer } from '../../web/server.js';
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export async function webCommand(ctx: AgentContext, args: string[]): Promise<void> {
+  const port = parseInt(flagValue(args, '--port') ?? process.env.GITD_WEB_PORT ?? '8080', 10);
+
+  console.log('Starting gitd web UI...');
+  startWebServer({ ctx, port });
+
+  // Keep the process alive — the server runs until Ctrl+C.
+  await new Promise(() => {});
+}

package/src/cli/commands/wiki.ts

@@ -0,0 +1,199 @@
+/**
+ * `gitd wiki` — collaborative documentation pages.
+ *
+ * Usage:
+ *   gitd wiki create <slug> <title> [--body <markdown>]
+ *   gitd wiki show <slug>
+ *   gitd wiki edit <slug> --body <markdown> [--summary <text>]
+ *   gitd wiki list
+ *
+ * @module
+ */
+
+import type { AgentContext } from '../agent.js';
+
+import { flagValue } from '../flags.js';
+import { getRepoContextId } from '../repo-context.js';
+
+// ---------------------------------------------------------------------------
+// Sub-command dispatch
+// ---------------------------------------------------------------------------
+
+export async function wikiCommand(ctx: AgentContext, args: string[]): Promise<void> {
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  switch (sub) {
+    case 'create': return wikiCreate(ctx, rest);
+    case 'show': return wikiShow(ctx, rest);
+    case 'edit': return wikiEdit(ctx, rest);
+    case 'list':
+    case 'ls': return wikiList(ctx, rest);
+    default:
+      console.error('Usage: gitd wiki <create|show|edit|list>');
+      process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// wiki create
+// ---------------------------------------------------------------------------
+
+async function wikiCreate(ctx: AgentContext, args: string[]): Promise<void> {
+  const slug = args[0];
+  const title = args[1];
+  const body = flagValue(args, '--body') ?? '';
+
+  if (!slug || !title) {
+    console.error('Usage: gitd wiki create <slug> <title> [--body <markdown>]');
+    process.exit(1);
+  }
+
+  const repoContextId = await getRepoContextId(ctx);
+
+  // Check for duplicate slug.
+  const existing = await findPageBySlug(ctx, repoContextId, slug);
+  if (existing) {
+    console.error(`Wiki page "${slug}" already exists. Use \`gitd wiki edit ${slug}\` to update it.`);
+    process.exit(1);
+  }
+
+  const { status, record } = await ctx.wiki.records.create('repo/page' as any, {
+    data            : body,
+    dataFormat      : 'text/markdown',
+    tags            : { slug, title },
+    parentContextId : repoContextId,
+  } as any);
+
+  if (status.code >= 300) {
+    console.error(`Failed to create wiki page: ${status.code} ${status.detail}`);
+    process.exit(1);
+  }
+
+  console.log(`Created wiki page: ${title} (/${slug})`);
+  console.log(`  Record ID: ${record.id}`);
+}
+
+// ---------------------------------------------------------------------------
+// wiki show
+// ---------------------------------------------------------------------------
+
+async function wikiShow(ctx: AgentContext, args: string[]): Promise<void> {
+  const slug = args[0];
+  if (!slug) {
+    console.error('Usage: gitd wiki show <slug>');
+    process.exit(1);
+  }
+
+  const repoContextId = await getRepoContextId(ctx);
+  const page = await findPageBySlug(ctx, repoContextId, slug);
+  if (!page) {
+    console.error(`Wiki page "${slug}" not found.`);
+    process.exit(1);
+  }
+
+  const tags = page.tags as Record<string, string> | undefined;
+  const title = tags?.title ?? slug;
+  const date = page.dateCreated?.slice(0, 10) ?? '';
+  const modified = (page as any).dateModified?.slice(0, 10) ?? date;
+
+  // Wiki pages use text/markdown as the data format.
+  const blob = await page.data.blob();
+  const content = await blob.text();
+
+  console.log(`Wiki: ${title} (/${slug})`);
+  console.log(`  Created:  ${date}`);
+  if (modified !== date) {
+    console.log(`  Modified: ${modified}`);
+  }
+  console.log(`  ID:       ${page.id}`);
+  console.log('');
+  console.log(content);
+}
+
+// ---------------------------------------------------------------------------
+// wiki edit
+// ---------------------------------------------------------------------------
+
+async function wikiEdit(ctx: AgentContext, args: string[]): Promise<void> {
+  const slug = args[0];
+  const body = flagValue(args, '--body');
+  const summary = flagValue(args, '--summary');
+
+  if (!slug || !body) {
+    console.error('Usage: gitd wiki edit <slug> --body <markdown> [--summary <text>]');
+    process.exit(1);
+  }
+
+  const repoContextId = await getRepoContextId(ctx);
+  const page = await findPageBySlug(ctx, repoContextId, slug);
+  if (!page) {
+    console.error(`Wiki page "${slug}" not found. Use \`gitd wiki create\` first.`);
+    process.exit(1);
+  }
+
+  const tags = page.tags as Record<string, string> | undefined;
+
+  const { status } = await page.update({
+    data       : body,
+    dataFormat : 'text/markdown',
+    tags       : { ...tags },
+  });
+
+  if (status.code >= 300) {
+    console.error(`Failed to update wiki page: ${status.code} ${status.detail}`);
+    process.exit(1);
+  }
+
+  // Create a history entry (immutable audit trail).
+  await ctx.wiki.records.create('repo/page/pageHistory' as any, {
+    data            : { editedBy: ctx.did, summary: summary ?? 'Page updated' },
+    parentContextId : page.contextId,
+  } as any);
+
+  console.log(`Updated wiki page: ${tags?.title ?? slug} (/${slug})`);
+}
+
+// ---------------------------------------------------------------------------
+// wiki list
+// ---------------------------------------------------------------------------
+
+async function wikiList(ctx: AgentContext, _args: string[]): Promise<void> {
+  const repoContextId = await getRepoContextId(ctx);
+
+  const { records } = await ctx.wiki.records.query('repo/page' as any, {
+    filter: { contextId: repoContextId },
+  });
+
+  if (records.length === 0) {
+    console.log('No wiki pages found.');
+    return;
+  }
+
+  console.log(`Wiki pages (${records.length}):\n`);
+  for (const rec of records) {
+    const tags = rec.tags as Record<string, string> | undefined;
+    const slug = tags?.slug ?? '?';
+    const title = tags?.title ?? slug;
+    const date = (rec as any).dateModified?.slice(0, 10) ?? rec.dateCreated?.slice(0, 10) ?? '';
+    console.log(`  /${slug.padEnd(20)} ${title}  ${date}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async function findPageBySlug(
+  ctx: AgentContext,
+  repoContextId: string,
+  slug: string,
+): Promise<any | undefined> {
+  const { records } = await ctx.wiki.records.query('repo/page' as any, {
+    filter: {
+      contextId : repoContextId,
+      tags      : { slug },
+    },
+  });
+  return records[0];
+}

package/src/cli/flags.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared CLI argument helpers.
+ *
+ * @module
+ */
+
+/** Extract the value following a flag in argv (e.g. `--port 8080`). */
+export function flagValue(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) { return undefined; }
+  return args[idx + 1];
+}
+
+/**
+ * Parse a port number string, validating that it's a valid TCP port.
+ * Exits the process with an error if the value is not a valid port.
+ *
+ * @param value - The port string to parse
+ * @returns A valid port number (1–65535)
+ */
+export function parsePort(value: string): number {
+  const port = parseInt(value, 10);
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    console.error(`Invalid port number: '${value}'. Must be an integer between 1 and 65535.`);
+    process.exit(1);
+  }
+  return port;
+}