@fureworks/scope 0.1.0 → 0.2.0

package/src/sources/calendar.ts

@@ -1,170 +0,0 @@
-export interface CalendarEvent {
-  title: string;
-  startTime: Date;
-  endTime: Date;
-  minutesUntilStart: number;
-}
-
-export interface CalendarSignal {
-  events: CalendarEvent[];
-  freeBlocks: FreeBlock[];
-}
-
-export interface FreeBlock {
-  start: Date;
-  end: Date;
-  durationMinutes: number;
-}
-
-export async function getCalendarToday(): Promise<CalendarSignal | null> {
-  try {
-    const { execSync } = await import("node:child_process");
-
-    // Check if gws is installed
-    try {
-      execSync("which gws", { stdio: "pipe" });
-    } catch {
-      return null;
-    }
-
-    // Get today's events via gws calendar +agenda --today
-    const result = execSync(
-      `gws calendar +agenda --today --format json 2>/dev/null`,
-      {
-        encoding: "utf-8",
-        timeout: 15000,
-        stdio: ["pipe", "pipe", "pipe"],
-      }
-    );
-
-    let items: Array<{
-      summary?: string;
-      title?: string;
-      start?: string | { dateTime?: string; date?: string };
-      end?: string | { dateTime?: string; date?: string };
-      startTime?: string;
-      endTime?: string;
-    }>;
-
-    try {
-      const data = JSON.parse(result);
-      // gws may return array directly or nested in a field
-      items = Array.isArray(data) ? data : data.items || data.events || [];
-    } catch {
-      // Try parsing as NDJSON (one JSON object per line)
-      items = result
-        .trim()
-        .split("\n")
-        .filter((line) => line.trim())
-        .flatMap((line) => {
-          try {
-            const parsed = JSON.parse(line);
-            // Could be a wrapper with items array or a single event
-            if (Array.isArray(parsed)) return parsed;
-            if (parsed.items) return parsed.items;
-            if (parsed.events) return parsed.events;
-            return [parsed];
-          } catch {
-            return [];
-          }
-        });
-    }
-
-    const now = Date.now();
-
-    const events: CalendarEvent[] = items
-      .map((item) => {
-        // Handle various gws output formats
-        const startStr =
-          typeof item.start === "string"
-            ? item.start
-            : item.start?.dateTime || item.startTime;
-        const endStr =
-          typeof item.end === "string"
-            ? item.end
-            : item.end?.dateTime || item.endTime;
-        const title = item.summary || item.title || "Untitled event";
-
-        if (!startStr) return null;
-
-        const startTime = new Date(startStr);
-        const endTime = endStr ? new Date(endStr) : new Date(startTime.getTime() + 60 * 60 * 1000);
-
-        if (isNaN(startTime.getTime())) return null;
-
-        return {
-          title,
-          startTime,
-          endTime,
-          minutesUntilStart: Math.round(
-            (startTime.getTime() - now) / (1000 * 60)
-          ),
-        };
-      })
-      .filter((e): e is CalendarEvent => e !== null)
-      .sort((a, b) => a.startTime.getTime() - b.startTime.getTime());
-
-    // Calculate free blocks (between events, min 30 min)
-    const freeBlocks = calculateFreeBlocks(events, new Date());
-
-    return { events, freeBlocks };
-  } catch {
-    return null;
-  }
-}
-
-function calculateFreeBlocks(
-  events: CalendarEvent[],
-  today: Date
-): FreeBlock[] {
-  const blocks: FreeBlock[] = [];
-  const now = new Date();
-
-  // Working hours: 9am to 6pm
-  const workStart = new Date(today);
-  workStart.setHours(9, 0, 0, 0);
-  const workEnd = new Date(today);
-  workEnd.setHours(18, 0, 0, 0);
-
-  // Start from now or work start, whichever is later
-  let cursor = new Date(Math.max(now.getTime(), workStart.getTime()));
-
-  const futureEvents = events.filter(
-    (e) => e.endTime.getTime() > cursor.getTime()
-  );
-
-  for (const event of futureEvents) {
-    if (event.startTime.getTime() > cursor.getTime()) {
-      const gapMinutes = Math.round(
-        (event.startTime.getTime() - cursor.getTime()) / (1000 * 60)
-      );
-      if (gapMinutes >= 30) {
-        blocks.push({
-          start: new Date(cursor),
-          end: new Date(event.startTime),
-          durationMinutes: gapMinutes,
-        });
-      }
-    }
-    // Move cursor past this event
-    if (event.endTime.getTime() > cursor.getTime()) {
-      cursor = new Date(event.endTime);
-    }
-  }
-
-  // Check for free time after last event until end of work
-  if (cursor.getTime() < workEnd.getTime()) {
-    const gapMinutes = Math.round(
-      (workEnd.getTime() - cursor.getTime()) / (1000 * 60)
-    );
-    if (gapMinutes >= 30) {
-      blocks.push({
-        start: new Date(cursor),
-        end: new Date(workEnd),
-        durationMinutes: gapMinutes,
-      });
-    }
-  }
-
-  return blocks;
-}

package/src/sources/git.ts

@@ -1,168 +0,0 @@
-import { simpleGit, SimpleGit } from "simple-git";
-import { existsSync } from "node:fs";
-
-export interface GitSignal {
-  repo: string;
-  branch: string;
-  uncommittedFiles: number;
-  lastCommitAge: number; // hours since last commit
-  staleBranches: string[]; // branches untouched > 3 days
-  openPRs: PRInfo[];
-}
-
-export interface PRInfo {
-  number: number;
-  title: string;
-  url: string;
-  ageDays: number;
-  reviewRequested: boolean;
-  ciStatus: "pass" | "fail" | "pending" | "unknown";
-  hasConflicts: boolean;
-}
-
-export async function scanRepo(repoPath: string): Promise<GitSignal | null> {
-  if (!existsSync(repoPath)) {
-    return null;
-  }
-
-  const git: SimpleGit = simpleGit(repoPath);
-
-  try {
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) return null;
-
-    // Get current branch
-    const branchInfo = await git.branch();
-    const branch = branchInfo.current;
-
-    // Get uncommitted changes
-    const status = await git.status();
-    const uncommittedFiles =
-      status.modified.length +
-      status.not_added.length +
-      status.created.length +
-      status.deleted.length;
-
-    // Get last commit time
-    let lastCommitAge = 0;
-    try {
-      const log = await git.log({ maxCount: 1 });
-      if (log.latest?.date) {
-        const lastCommitDate = new Date(log.latest.date);
-        lastCommitAge =
-          (Date.now() - lastCommitDate.getTime()) / (1000 * 60 * 60);
-      }
-    } catch {
-      // No commits yet
-    }
-
-    // Get stale branches (untouched > 3 days)
-    const staleBranches: string[] = [];
-    try {
-      const branches = await git.branch(["-a", "--sort=-committerdate"]);
-      const threeDaysAgo = Date.now() - 3 * 24 * 60 * 60 * 1000;
-
-      for (const branchName of branches.all) {
-        if (branchName === branch) continue;
-        if (branchName.startsWith("remotes/")) continue;
-
-        try {
-          const branchLog = await git.log({
-            maxCount: 1,
-            from: branchName,
-          });
-          if (branchLog.latest?.date) {
-            const branchDate = new Date(branchLog.latest.date);
-            if (branchDate.getTime() < threeDaysAgo) {
-              staleBranches.push(branchName);
-            }
-          }
-        } catch {
-          // Skip branches we can't read
-        }
-      }
-    } catch {
-      // Branch listing failed
-    }
-
-    // Get open PRs via gh CLI
-    const openPRs = await getOpenPRs(repoPath);
-
-    const repoName = repoPath.split("/").pop() || repoPath;
-
-    return {
-      repo: repoName,
-      branch,
-      uncommittedFiles,
-      lastCommitAge,
-      staleBranches: staleBranches.slice(0, 5), // Cap at 5
-      openPRs,
-    };
-  } catch {
-    return null;
-  }
-}
-
-async function getOpenPRs(repoPath: string): Promise<PRInfo[]> {
-  try {
-    const { execSync } = await import("node:child_process");
-    const result = execSync(
-      `gh pr list --json number,title,url,createdAt,reviewRequests,statusCheckRollup,mergeable --limit 10`,
-      {
-        cwd: repoPath,
-        encoding: "utf-8",
-        timeout: 10000,
-        stdio: ["pipe", "pipe", "pipe"],
-      }
-    );
-
-    const prs = JSON.parse(result) as Array<{
-      number: number;
-      title: string;
-      url: string;
-      createdAt: string;
-      reviewRequests: Array<{ login?: string }>;
-      statusCheckRollup: Array<{ conclusion: string }> | null;
-      mergeable: string;
-    }>;
-
-    return prs.map((pr) => {
-      const ageDays =
-        (Date.now() - new Date(pr.createdAt).getTime()) /
-        (1000 * 60 * 60 * 24);
-
-      let ciStatus: PRInfo["ciStatus"] = "unknown";
-      if (pr.statusCheckRollup && pr.statusCheckRollup.length > 0) {
-        const hasFailure = pr.statusCheckRollup.some(
-          (c) => c.conclusion === "FAILURE"
-        );
-        const allSuccess = pr.statusCheckRollup.every(
-          (c) => c.conclusion === "SUCCESS"
-        );
-        if (hasFailure) ciStatus = "fail";
-        else if (allSuccess) ciStatus = "pass";
-        else ciStatus = "pending";
-      }
-
-      return {
-        number: pr.number,
-        title: pr.title,
-        url: pr.url,
-        ageDays: Math.round(ageDays * 10) / 10,
-        reviewRequested: pr.reviewRequests.length > 0,
-        ciStatus,
-        hasConflicts: pr.mergeable === "CONFLICTING",
-      };
-    });
-  } catch {
-    // gh CLI not available or not in a repo with remote
-    return [];
-  }
-}
-
-export async function scanAllRepos(
-  repoPaths: string[]
-): Promise<GitSignal[]> {
-  const results = await Promise.all(repoPaths.map(scanRepo));
-  return results.filter((r): r is GitSignal => r !== null);
-}

package/src/sources/issues.ts

@@ -1,62 +0,0 @@
-export interface IssueSignal {
-  number: number;
-  title: string;
-  url: string;
-  repo: string;
-  ageDays: number;
-  labels: string[];
-}
-
-export interface IssueScanResult {
-  available: boolean;
-  issues: IssueSignal[];
-}
-
-export async function scanAssignedIssues(): Promise<IssueScanResult> {
-  try {
-    const { execSync } = await import("node:child_process");
-
-    try {
-      execSync("which gh", { stdio: "pipe" });
-    } catch {
-      return { available: false, issues: [] };
-    }
-
-    const result = execSync(
-      "gh issue list --assignee @me --state open --json number,title,url,createdAt,labels,repository --limit 20",
-      {
-        encoding: "utf-8",
-        timeout: 10000,
-        stdio: ["pipe", "pipe", "pipe"],
-      }
-    );
-
-    const parsed = JSON.parse(result) as Array<{
-      number: number;
-      title: string;
-      url: string;
-      createdAt: string;
-      labels?: Array<{ name?: string }>;
-      repository?: { nameWithOwner?: string; name?: string };
-    }>;
-
-    const issues: IssueSignal[] = parsed.map((issue) => {
-      const ageDays =
-        (Date.now() - new Date(issue.createdAt).getTime()) /
-        (1000 * 60 * 60 * 24);
-
-      return {
-        number: issue.number,
-        title: issue.title,
-        url: issue.url,
-        repo: issue.repository?.nameWithOwner || issue.repository?.name || "unknown",
-        ageDays: Math.round(ageDays * 10) / 10,
-        labels: (issue.labels ?? []).map((label) => label.name || "").filter(Boolean),
-      };
-    });
-
-    return { available: true, issues };
-  } catch {
-    return { available: true, issues: [] };
-  }
-}

package/src/store/config.ts

@@ -1,104 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { parse as parseToml } from "toml";
-
-export interface ScopeConfig {
-  repos: string[];
-  projects: Record<
-    string,
-    {
-      path: string;
-      repos?: string[];
-      description?: string;
-    }
-  >;
-  calendar: {
-    enabled: boolean;
-    backend: "gws";
-  };
-  daemon: {
-    enabled: boolean;
-    intervalMinutes: number;
-  };
-}
-
-const SCOPE_DIR = join(homedir(), ".scope");
-const CONFIG_PATH = join(SCOPE_DIR, "config.toml");
-
-export function getScopeDir(): string {
-  return SCOPE_DIR;
-}
-
-export function ensureScopeDir(): void {
-  if (!existsSync(SCOPE_DIR)) {
-    mkdirSync(SCOPE_DIR, { recursive: true });
-  }
-  const contextsDir = join(SCOPE_DIR, "contexts");
-  if (!existsSync(contextsDir)) {
-    mkdirSync(contextsDir, { recursive: true });
-  }
-}
-
-export function configExists(): boolean {
-  return existsSync(CONFIG_PATH);
-}
-
-export function loadConfig(): ScopeConfig {
-  if (!configExists()) {
-    return {
-      repos: [],
-      projects: {},
-      calendar: { enabled: false, backend: "gws" },
-      daemon: { enabled: false, intervalMinutes: 15 },
-    };
-  }
-
-  const raw = readFileSync(CONFIG_PATH, "utf-8");
-  const parsed = parseToml(raw) as Partial<ScopeConfig>;
-
-  return {
-    repos: parsed.repos ?? [],
-    projects: parsed.projects ?? {},
-    calendar: {
-      enabled: parsed.calendar?.enabled ?? false,
-      backend: parsed.calendar?.backend ?? "gws",
-    },
-    daemon: {
-      enabled: parsed.daemon?.enabled ?? false,
-      intervalMinutes: parsed.daemon?.intervalMinutes ?? 15,
-    },
-  };
-}
-
-export function saveConfig(config: ScopeConfig): void {
-  ensureScopeDir();
-
-  const lines: string[] = [];
-  lines.push("# Scope configuration");
-  lines.push("");
-  lines.push(`repos = [${config.repos.map((r) => `"${r}"`).join(", ")}]`);
-  lines.push("");
-  lines.push("[calendar]");
-  lines.push(`enabled = ${config.calendar.enabled}`);
-  lines.push(`backend = "${config.calendar.backend}"`);
-  lines.push("");
-  lines.push("[daemon]");
-  lines.push(`enabled = ${config.daemon.enabled}`);
-  lines.push(`intervalMinutes = ${config.daemon.intervalMinutes}`);
-  lines.push("");
-
-  for (const [name, project] of Object.entries(config.projects)) {
-    lines.push(`[projects.${name}]`);
-    lines.push(`path = "${project.path}"`);
-    if (project.repos && project.repos.length > 0) {
-      lines.push(`repos = [${project.repos.map((r) => `"${r}"`).join(", ")}]`);
-    }
-    if (project.description) {
-      lines.push(`description = "${project.description}"`);
-    }
-    lines.push("");
-  }
-
-  writeFileSync(CONFIG_PATH, lines.join("\n"), "utf-8");
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}