panopticon-cli 0.4.31 → 0.4.33

package/dist/chunk-XKT5MHPT.js

@@ -0,0 +1,677 @@
+import {
+  buildManifestFromDirectory,
+  collectSourceFiles,
+  compareFileToManifest,
+  hashFile,
+  init_manifest,
+  readManifest,
+  setManifestEntry,
+  writeManifest
+} from "./chunk-AQXETQHW.js";
+import {
+  init_factory,
+  init_github,
+  init_gitlab,
+  init_linear
+} from "./chunk-XFR2DLMR.js";
+import {
+  getDevrootPath,
+  init_config
+} from "./chunk-FQ66DECN.js";
+import {
+  init_interface
+} from "./chunk-CFCUOV3Q.js";
+import {
+  BACKUPS_DIR,
+  BIN_DIR,
+  CACHE_AGENTS_DIR,
+  CACHE_MANIFEST,
+  CACHE_RULES_DIR,
+  SKILLS_DIR,
+  SOURCE_AGENTS_DIR,
+  SOURCE_DEV_SKILLS_DIR,
+  SOURCE_RULES_DIR,
+  SOURCE_SCRIPTS_DIR,
+  SOURCE_SKILLS_DIR,
+  init_paths,
+  isDevMode
+} from "./chunk-ZTFNYOC7.js";
+import {
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/shell.ts
+init_esm_shims();
+import { existsSync, readFileSync, appendFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function detectShell() {
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("bash")) return "bash";
+  if (shell.includes("fish")) return "fish";
+  return "unknown";
+}
+function getShellRcFile(shell) {
+  const home = homedir();
+  switch (shell) {
+    case "zsh":
+      return join(home, ".zshrc");
+    case "bash":
+      const bashrc = join(home, ".bashrc");
+      if (existsSync(bashrc)) return bashrc;
+      return join(home, ".bash_profile");
+    case "fish":
+      return join(home, ".config", "fish", "config.fish");
+    default:
+      return null;
+  }
+}
+var ALIAS_LINE = 'alias pan="panopticon"';
+var ALIAS_MARKER = "# Panopticon CLI alias";
+function hasAlias(rcFile) {
+  if (!existsSync(rcFile)) return false;
+  const content = readFileSync(rcFile, "utf8");
+  return content.includes(ALIAS_MARKER) || content.includes(ALIAS_LINE);
+}
+function addAlias(rcFile) {
+  if (hasAlias(rcFile)) return;
+  const aliasBlock = `
+${ALIAS_MARKER}
+${ALIAS_LINE}
+`;
+  appendFileSync(rcFile, aliasBlock, "utf8");
+}
+function getAliasInstructions(shell) {
+  const rcFile = getShellRcFile(shell);
+  if (!rcFile) {
+    return `Add this to your shell config:
+  ${ALIAS_LINE}`;
+  }
+  return `Alias added to ${rcFile}. Run:
+  source ${rcFile}`;
+}
+
+// src/lib/backup.ts
+init_esm_shims();
+init_paths();
+import { existsSync as existsSync2, mkdirSync, readdirSync, cpSync, rmSync, lstatSync } from "fs";
+import { join as join2, basename } from "path";
+function createBackupTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function createBackup(sourceDirs) {
+  const timestamp = createBackupTimestamp();
+  const backupPath = join2(BACKUPS_DIR, timestamp);
+  mkdirSync(backupPath, { recursive: true });
+  const targets = [];
+  for (const sourceDir of sourceDirs) {
+    if (!existsSync2(sourceDir)) continue;
+    const targetName = basename(sourceDir);
+    const targetPath = join2(backupPath, targetName);
+    cpSync(sourceDir, targetPath, {
+      recursive: true,
+      filter: (src) => !lstatSync(src).isSymbolicLink()
+    });
+    targets.push(targetName);
+  }
+  return {
+    timestamp,
+    path: backupPath,
+    targets
+  };
+}
+function listBackups() {
+  if (!existsSync2(BACKUPS_DIR)) return [];
+  const entries = readdirSync(BACKUPS_DIR, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => {
+    const backupPath = join2(BACKUPS_DIR, e.name);
+    const contents = readdirSync(backupPath);
+    return {
+      timestamp: e.name,
+      path: backupPath,
+      targets: contents
+    };
+  }).sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
+function restoreBackup(timestamp, targetDirs) {
+  const backupPath = join2(BACKUPS_DIR, timestamp);
+  if (!existsSync2(backupPath)) {
+    throw new Error(`Backup not found: ${timestamp}`);
+  }
+  const contents = readdirSync(backupPath, { withFileTypes: true });
+  for (const entry of contents) {
+    if (!entry.isDirectory()) continue;
+    const sourcePath = join2(backupPath, entry.name);
+    const targetPath = targetDirs[entry.name];
+    if (!targetPath) continue;
+    if (existsSync2(targetPath)) {
+      rmSync(targetPath, { recursive: true });
+    }
+    cpSync(sourcePath, targetPath, { recursive: true });
+  }
+}
+function cleanOldBackups(keepCount = 10) {
+  const backups = listBackups();
+  if (backups.length <= keepCount) return 0;
+  const toRemove = backups.slice(keepCount);
+  let removed = 0;
+  for (const backup of toRemove) {
+    rmSync(backup.path, { recursive: true });
+    removed++;
+  }
+  return removed;
+}
+
+// src/lib/sync.ts
+init_esm_shims();
+init_paths();
+init_manifest();
+init_config();
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, unlinkSync, lstatSync as lstatSync2, readlinkSync, rmSync as rmSync2, copyFileSync, chmodSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join3, dirname } from "path";
+import { homedir as homedir2 } from "os";
+function isPanopticonSymlink(targetPath) {
+  if (!existsSync3(targetPath)) return false;
+  try {
+    const stats = lstatSync2(targetPath);
+    if (!stats.isSymbolicLink()) return false;
+    const linkTarget = readlinkSync(targetPath);
+    return linkTarget.includes(".panopticon");
+  } catch {
+    return false;
+  }
+}
+function migrateFromPersonalSymlinks() {
+  const claudeDir = join3(homedir2(), ".claude");
+  const result = {
+    removedSymlinks: [],
+    preservedUserContent: [],
+    errors: []
+  };
+  for (const subdir of ["skills", "commands", "agents"]) {
+    const dir = join3(claudeDir, subdir);
+    if (!existsSync3(dir)) continue;
+    try {
+      const entries = readdirSync2(dir);
+      for (const entry of entries) {
+        const entryPath = join3(dir, entry);
+        try {
+          const stats = lstatSync2(entryPath);
+          if (stats.isSymbolicLink()) {
+            const linkTarget = readlinkSync(entryPath);
+            if (linkTarget.includes(".panopticon") || linkTarget.includes("panopticon-cli")) {
+              unlinkSync(entryPath);
+              result.removedSymlinks.push(`${subdir}/${entry}`);
+            } else {
+              result.preservedUserContent.push(`${subdir}/${entry}`);
+            }
+          } else {
+            result.preservedUserContent.push(`${subdir}/${entry}`);
+          }
+        } catch (err) {
+          result.errors.push(`${subdir}/${entry}: ${err.message}`);
+        }
+      }
+    } catch (err) {
+      result.errors.push(`${subdir}: ${err.message}`);
+    }
+  }
+  return result;
+}
+function copyDirectoryRecursive(source, dest) {
+  if (!existsSync3(source)) return 0;
+  mkdirSync2(dest, { recursive: true });
+  let count = 0;
+  const entries = readdirSync2(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join3(source, entry.name);
+    const dstPath = join3(dest, entry.name);
+    if (entry.isDirectory()) {
+      count += copyDirectoryRecursive(srcPath, dstPath);
+    } else if (entry.isFile()) {
+      copyFileSync(srcPath, dstPath);
+      count++;
+    }
+  }
+  return count;
+}
+function refreshCache() {
+  const result = {
+    skills: { copied: 0, total: 0 },
+    agents: { copied: 0, total: 0 },
+    rules: { copied: 0, total: 0 }
+  };
+  if (existsSync3(SOURCE_SKILLS_DIR)) {
+    const skillDirs = readdirSync2(SOURCE_SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+    result.skills.total = skillDirs.length;
+    for (const skillDir of skillDirs) {
+      const src = join3(SOURCE_SKILLS_DIR, skillDir.name);
+      const dst = join3(SKILLS_DIR, skillDir.name);
+      copyDirectoryRecursive(src, dst);
+      result.skills.copied++;
+    }
+  }
+  if (isDevMode() && existsSync3(SOURCE_DEV_SKILLS_DIR)) {
+    const devSkillDirs = readdirSync2(SOURCE_DEV_SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const skillDir of devSkillDirs) {
+      const src = join3(SOURCE_DEV_SKILLS_DIR, skillDir.name);
+      const dst = join3(SKILLS_DIR, skillDir.name);
+      copyDirectoryRecursive(src, dst);
+      result.skills.copied++;
+      result.skills.total++;
+    }
+  }
+  if (existsSync3(SOURCE_AGENTS_DIR)) {
+    mkdirSync2(CACHE_AGENTS_DIR, { recursive: true });
+    const agents = readdirSync2(SOURCE_AGENTS_DIR, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md"));
+    result.agents.total = agents.length;
+    for (const agent of agents) {
+      copyFileSync(join3(SOURCE_AGENTS_DIR, agent.name), join3(CACHE_AGENTS_DIR, agent.name));
+      result.agents.copied++;
+    }
+  }
+  if (existsSync3(SOURCE_RULES_DIR)) {
+    const ruleFiles = readdirSync2(SOURCE_RULES_DIR, { withFileTypes: true }).filter((entry) => entry.isFile());
+    result.rules.total = ruleFiles.length;
+    for (const rule of ruleFiles) {
+      mkdirSync2(CACHE_RULES_DIR, { recursive: true });
+      copyFileSync(join3(SOURCE_RULES_DIR, rule.name), join3(CACHE_RULES_DIR, rule.name));
+      result.rules.copied++;
+    }
+  }
+  const manifest = buildManifestFromDirectory(
+    join3(SKILLS_DIR, ".."),
+    // ~/.panopticon/
+    ["skills", "agent-definitions", "rules"],
+    "panopticon"
+  );
+  writeManifest(CACHE_MANIFEST, manifest);
+  return result;
+}
+function planSync() {
+  const plan = {
+    skills: [],
+    commands: [],
+    agents: [],
+    rules: [],
+    devSkills: []
+  };
+  const devrootPath = getDevrootPath();
+  if (!devrootPath) return plan;
+  const targetBase = join3(devrootPath, ".claude");
+  const manifestPath = join3(targetBase, ".panopticon-manifest.json");
+  const manifest = readManifest(manifestPath);
+  const skillFiles = collectSourceFiles(SKILLS_DIR, "skills/");
+  for (const file of skillFiles) {
+    const targetFile = join3(targetBase, file.relativePath);
+    const status = compareFileToManifest(targetFile, file.relativePath, manifest);
+    const skillName = file.relativePath.split("/")[1] || file.relativePath;
+    let syncStatus = "new";
+    if (status.action === "update") syncStatus = "symlink";
+    else if (status.action === "modified") syncStatus = "conflict";
+    else if (status.action === "user-owned") syncStatus = "conflict";
+    plan.skills.push({
+      name: file.relativePath,
+      sourcePath: file.absolutePath,
+      targetPath: targetFile,
+      status: syncStatus
+    });
+  }
+  const agentFiles = collectSourceFiles(CACHE_AGENTS_DIR, "agents/");
+  for (const file of agentFiles) {
+    const targetFile = join3(targetBase, file.relativePath);
+    const status = compareFileToManifest(targetFile, file.relativePath, manifest);
+    let syncStatus = "new";
+    if (status.action === "update") syncStatus = "symlink";
+    else if (status.action === "modified") syncStatus = "conflict";
+    else if (status.action === "user-owned") syncStatus = "conflict";
+    plan.agents.push({
+      name: file.relativePath,
+      sourcePath: file.absolutePath,
+      targetPath: targetFile,
+      status: syncStatus
+    });
+  }
+  const ruleFiles = collectSourceFiles(CACHE_RULES_DIR, "rules/");
+  for (const file of ruleFiles) {
+    const targetFile = join3(targetBase, file.relativePath);
+    const status = compareFileToManifest(targetFile, file.relativePath, manifest);
+    let syncStatus = "new";
+    if (status.action === "update") syncStatus = "symlink";
+    else if (status.action === "modified") syncStatus = "conflict";
+    else if (status.action === "user-owned") syncStatus = "conflict";
+    plan.rules.push({
+      name: file.relativePath,
+      sourcePath: file.absolutePath,
+      targetPath: targetFile,
+      status: syncStatus
+    });
+  }
+  return plan;
+}
+function executeSync(options = {}) {
+  const result = {
+    created: [],
+    updated: [],
+    skipped: [],
+    conflicts: [],
+    diffs: []
+  };
+  const devrootPath = getDevrootPath();
+  if (!devrootPath) {
+    return result;
+  }
+  const targetBase = join3(devrootPath, ".claude");
+  const manifestPath = join3(targetBase, ".panopticon-manifest.json");
+  const manifest = readManifest(manifestPath);
+  const allFiles = [
+    ...collectSourceFiles(SKILLS_DIR, "skills/"),
+    ...collectSourceFiles(CACHE_AGENTS_DIR, "agents/"),
+    ...collectSourceFiles(CACHE_RULES_DIR, "rules/")
+  ];
+  for (const file of allFiles) {
+    const targetFile = join3(targetBase, file.relativePath);
+    const status = compareFileToManifest(targetFile, file.relativePath, manifest);
+    switch (status.action) {
+      case "new": {
+        mkdirSync2(dirname(targetFile), { recursive: true });
+        copyFileSync(file.absolutePath, targetFile);
+        const hash = hashFile(targetFile);
+        setManifestEntry(manifest, file.relativePath, hash, "panopticon");
+        result.created.push(file.relativePath);
+        break;
+      }
+      case "update": {
+        mkdirSync2(dirname(targetFile), { recursive: true });
+        copyFileSync(file.absolutePath, targetFile);
+        const hash = hashFile(targetFile);
+        setManifestEntry(manifest, file.relativePath, hash, "panopticon");
+        result.updated.push(file.relativePath);
+        break;
+      }
+      case "modified": {
+        if (options.diff) {
+          result.diffs.push({
+            path: file.relativePath,
+            sourceContent: readFileSync2(file.absolutePath, "utf-8"),
+            targetContent: readFileSync2(targetFile, "utf-8")
+          });
+        }
+        if (options.force) {
+          mkdirSync2(dirname(targetFile), { recursive: true });
+          copyFileSync(file.absolutePath, targetFile);
+          const hash = hashFile(targetFile);
+          setManifestEntry(manifest, file.relativePath, hash, "panopticon");
+          result.updated.push(file.relativePath);
+        } else {
+          result.conflicts.push(file.relativePath);
+        }
+        break;
+      }
+      case "user-owned": {
+        result.skipped.push(file.relativePath);
+        break;
+      }
+    }
+  }
+  writeManifest(manifestPath, manifest);
+  return result;
+}
+function planHooksSync() {
+  const hooks = [];
+  if (!existsSync3(SOURCE_SCRIPTS_DIR)) {
+    return hooks;
+  }
+  const scripts = readdirSync2(SOURCE_SCRIPTS_DIR, { withFileTypes: true }).filter((entry) => entry.isFile() && !entry.name.startsWith(".") && (!entry.name.includes(".") || entry.name.endsWith(".js")));
+  for (const script of scripts) {
+    const sourcePath = join3(SOURCE_SCRIPTS_DIR, script.name);
+    const targetPath = join3(BIN_DIR, script.name);
+    let status = "new";
+    if (existsSync3(targetPath)) {
+      status = "updated";
+    }
+    hooks.push({ name: script.name, sourcePath, targetPath, status });
+  }
+  return hooks;
+}
+function syncHooks() {
+  const result = { synced: [], errors: [] };
+  mkdirSync2(BIN_DIR, { recursive: true });
+  const hooks = planHooksSync();
+  for (const hook of hooks) {
+    try {
+      copyFileSync(hook.sourcePath, hook.targetPath);
+      chmodSync(hook.targetPath, 493);
+      result.synced.push(hook.name);
+    } catch (error) {
+      result.errors.push(`${hook.name}: ${error}`);
+    }
+  }
+  return result;
+}
+var STATUSLINE_TARGETS = {
+  claude: {
+    configDir: join3(homedir2(), ".claude"),
+    scriptName: "statusline-command.sh",
+    settingsFile: join3(homedir2(), ".claude", "settings.json")
+  }
+  // Other runtimes can be added as they support statusline
+};
+function syncStatusline() {
+  const result = { synced: [], errors: [] };
+  const sourceScript = join3(SOURCE_SCRIPTS_DIR, "statusline.sh");
+  if (!existsSync3(sourceScript)) {
+    return result;
+  }
+  for (const [runtime, target] of Object.entries(STATUSLINE_TARGETS)) {
+    try {
+      mkdirSync2(target.configDir, { recursive: true });
+      const targetScript = join3(target.configDir, target.scriptName);
+      copyFileSync(sourceScript, targetScript);
+      chmodSync(targetScript, 493);
+      updateSettingsStatusline(target.settingsFile, targetScript);
+      result.synced.push(runtime);
+    } catch (error) {
+      result.errors.push(`${runtime}: ${error}`);
+    }
+  }
+  return result;
+}
+function updateSettingsStatusline(settingsFile, scriptPath) {
+  let settings = {};
+  if (existsSync3(settingsFile)) {
+    try {
+      settings = JSON.parse(readFileSync2(settingsFile, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+  const currentCommand = settings.statusLine?.command;
+  if (currentCommand === scriptPath && settings.statusLine?.type === "command") {
+    return;
+  }
+  settings.statusLine = {
+    type: "command",
+    command: scriptPath,
+    padding: 0
+  };
+  mkdirSync2(dirname(settingsFile), { recursive: true });
+  writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+
+// src/lib/tracker/linking.ts
+init_esm_shims();
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+function parseIssueRef(ref) {
+  if (ref.startsWith("github#")) {
+    return { tracker: "github", ref: `#${ref.slice(7)}` };
+  }
+  if (ref.startsWith("gitlab#")) {
+    return { tracker: "gitlab", ref: `#${ref.slice(7)}` };
+  }
+  if (ref.startsWith("linear:")) {
+    return { tracker: "linear", ref: ref.slice(7) };
+  }
+  if (/^#\d+$/.test(ref)) {
+    return { tracker: "github", ref };
+  }
+  if (/^[A-Z]+-\d+$/i.test(ref)) {
+    return { tracker: "linear", ref: ref.toUpperCase() };
+  }
+  return null;
+}
+function formatIssueRef(ref, tracker) {
+  if (tracker === "github") {
+    return ref.startsWith("#") ? `github${ref}` : `github#${ref}`;
+  }
+  if (tracker === "gitlab") {
+    return ref.startsWith("#") ? `gitlab${ref}` : `gitlab#${ref}`;
+  }
+  return ref;
+}
+var LinkManager = class {
+  storePath;
+  store;
+  constructor(storePath) {
+    this.storePath = storePath ?? join4(homedir3(), ".panopticon", "links.json");
+    this.store = this.load();
+  }
+  load() {
+    if (existsSync4(this.storePath)) {
+      try {
+        const data = JSON.parse(readFileSync3(this.storePath, "utf-8"));
+        if (data.version === 1) {
+          return data;
+        }
+      } catch {
+      }
+    }
+    return { version: 1, links: [] };
+  }
+  save() {
+    const dir = join4(this.storePath, "..");
+    if (!existsSync4(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync2(this.storePath, JSON.stringify(this.store, null, 2));
+  }
+  /**
+   * Add a link between two issues
+   */
+  addLink(source, target, direction = "related") {
+    const existing = this.store.links.find(
+      (l) => l.sourceIssueRef === source.ref && l.sourceTracker === source.tracker && l.targetIssueRef === target.ref && l.targetTracker === target.tracker
+    );
+    if (existing) {
+      if (existing.direction !== direction) {
+        existing.direction = direction;
+        this.save();
+      }
+      return existing;
+    }
+    const link = {
+      sourceIssueRef: source.ref,
+      sourceTracker: source.tracker,
+      targetIssueRef: target.ref,
+      targetTracker: target.tracker,
+      direction,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.store.links.push(link);
+    this.save();
+    return link;
+  }
+  /**
+   * Remove a link between two issues
+   */
+  removeLink(source, target) {
+    const index = this.store.links.findIndex(
+      (l) => l.sourceIssueRef === source.ref && l.sourceTracker === source.tracker && l.targetIssueRef === target.ref && l.targetTracker === target.tracker
+    );
+    if (index >= 0) {
+      this.store.links.splice(index, 1);
+      this.save();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get all issues linked to a given issue
+   */
+  getLinkedIssues(ref, tracker) {
+    return this.store.links.filter(
+      (l) => l.sourceIssueRef === ref && l.sourceTracker === tracker || l.targetIssueRef === ref && l.targetTracker === tracker
+    );
+  }
+  /**
+   * Get all links (for debugging/admin)
+   */
+  getAllLinks() {
+    return [...this.store.links];
+  }
+  /**
+   * Find linked issue in another tracker
+   */
+  findLinkedIssue(ref, sourceTracker, targetTracker) {
+    const asSource = this.store.links.find(
+      (l) => l.sourceIssueRef === ref && l.sourceTracker === sourceTracker && l.targetTracker === targetTracker
+    );
+    if (asSource) return asSource.targetIssueRef;
+    const asTarget = this.store.links.find(
+      (l) => l.targetIssueRef === ref && l.targetTracker === sourceTracker && l.sourceTracker === targetTracker
+    );
+    if (asTarget) return asTarget.sourceIssueRef;
+    return null;
+  }
+  /**
+   * Clear all links (for testing)
+   */
+  clear() {
+    this.store.links = [];
+    this.save();
+  }
+};
+var _linkManager = null;
+function getLinkManager() {
+  if (!_linkManager) {
+    _linkManager = new LinkManager();
+  }
+  return _linkManager;
+}
+
+// src/lib/tracker/index.ts
+init_esm_shims();
+init_interface();
+init_linear();
+init_github();
+init_gitlab();
+init_factory();
+
+export {
+  detectShell,
+  getShellRcFile,
+  hasAlias,
+  addAlias,
+  getAliasInstructions,
+  createBackupTimestamp,
+  createBackup,
+  listBackups,
+  restoreBackup,
+  cleanOldBackups,
+  isPanopticonSymlink,
+  migrateFromPersonalSymlinks,
+  refreshCache,
+  planSync,
+  executeSync,
+  planHooksSync,
+  syncHooks,
+  syncStatusline,
+  parseIssueRef,
+  formatIssueRef,
+  LinkManager,
+  getLinkManager
+};
+//# sourceMappingURL=chunk-XKT5MHPT.js.map