pf 0.0.1 → 0.0.2

package/utils.ts

@@ -0,0 +1,108 @@
+import { execSync, spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname } from "path";
+import pc from "picocolors";
+import { getGitCommonDir, getGitRoot } from "./store.js";
+
+export function getCurrentBranch(): string {
+  try {
+    return execSync("git branch --show-current", { encoding: "utf-8" }).trim() || "HEAD";
+  } catch {
+    return "HEAD";
+  }
+}
+
+export function getWorktreeBranch(path: string): string {
+  if (!existsSync(path)) {
+    return "[missing]";
+  }
+  try {
+    const branch = execSync(`git -C "${path}" branch --show-current`, { encoding: "utf-8" }).trim();
+    return branch || "[detached]";
+  } catch {
+    return "[detached]";
+  }
+}
+
+export function getWorktreeStatus(path: string): string {
+  if (!existsSync(path)) {
+    return "";
+  }
+  try {
+    const status = execSync(`git -C "${path}" status --porcelain`, { encoding: "utf-8" }).trim();
+    if (!status) {
+      return "clean";
+    }
+    const lines = status.split("\n").length;
+    return `${lines} changed`;
+  } catch {
+    return "[error]";
+  }
+}
+
+export function branchExists(name: string): boolean {
+  try {
+    execSync(`git show-ref --verify --quiet refs/heads/${name}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isInsideWorktree(): boolean {
+  try {
+    const gitRoot = getGitRoot();
+    const gitDir = getGitCommonDir();
+    return gitRoot !== dirname(gitDir);
+  } catch {
+    return false;
+  }
+}
+
+export function hasUncommittedChanges(): boolean {
+  try {
+    const status = execSync("git status --porcelain", { encoding: "utf-8" }).trim();
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export function createWorktree(name: string, path: string): void {
+  execSync(`git worktree add -b "${name}" "${path}"`, { stdio: "ignore" });
+}
+
+export function removeWorktree(path: string): void {
+  execSync(`git worktree remove "${path}"`, { stdio: "ignore" });
+}
+
+export function pruneWorktrees(): void {
+  try {
+    execSync("git worktree prune", { stdio: "ignore" });
+  } catch {
+    // ignore
+  }
+}
+
+export function deleteBranch(name: string): void {
+  execSync(`git branch -D "${name}"`, { stdio: "ignore" });
+}
+
+export function generateName(): string {
+  const bytes = new Uint8Array(4);
+  crypto.getRandomValues(bytes);
+  const hex = Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+  return `pf-${hex}`;
+}
+
+export function spawnShell(cwd: string): void {
+  const shell = process.env.SHELL || "/bin/sh";
+  spawnSync(shell, { cwd, stdio: "inherit" });
+}
+
+// Styled output helpers
+export const success = (text: string) => pc.green(pc.bold("✓")) + " " + text;
+export const dim = (text: string) => pc.dim(text);
+export const bold = (text: string) => pc.bold(text);

package/.npmignore

@@ -1 +0,0 @@
-node_modules

package/index.js

@@ -1,90 +0,0 @@
-/*jslint node: true */
-
-'use strict';
-
-var _ = require('lodash');
-
-function dsl(actions) {
-    var obj = Object.create(dsl.prototype);
-    obj._actions = actions || []; 
-    return obj;
-}
-
-['methods', 'call'].forEach(function (key) {
-    dsl[key] = function () {
-        var inst = dsl();
-        return inst[key].apply(inst, arguments);
-    };
-    dsl.prototype[key] = function () {
-        return dsl(this._actions.concat([[key, _.toArray(arguments)]]));
-    };
-});
-
-dsl.prototype.done = function () {
-    /**
-     * Methods for DSL
-     */
-    var methods = this._actions.filter(function (a) {
-        return a[0] === 'methods';
-    }).reduce(function (a, b) {
-        return a.concat(b[1][0]);
-    }, []);
-
-    /**
-     * Callable methods
-     */
-    var method_fns = this._actions.filter(function (a) {
-        return a[0] === 'call' && typeof a[1][0] !== 'function';
-    });
-
-    /**
-     * Is this DSL callable?  If it is, it makes our code a less efficient,
-     * because we can't do object delegation with functions.
-     */
-    var callable = _.find(this._actions, function (a) {
-        return a[0] === 'call' && typeof a[1][0] === 'function';
-    });
-    if (callable) {
-        callable = callable[1][0];
-    }
-
-    var create, prototype = {};
-
-    if (callable) {
-        create = function (opts) {
-            var obj = function () {
-                return callable.apply(obj, arguments);
-            };
-            _.extend(obj, prototype, opts);
-            obj._actions = obj._actions || [];
-            console.log('actions', obj._actions);
-
-            return obj;
-        };
-    } else {
-        throw new Error('@TODO non-callable DSL');
-    }
-
-    methods.forEach(function (method) {
-        prototype[method] = function () {
-            return create({
-                _actions: this._actions.concat([[method, _.toArray(arguments)]])
-            });
-        };
-    });
-
-    console.log('rwarr!!!', this, prototype);
-    return create();
-};
-
-var pf = dsl
-    .methods(['curry'])
-    .call(function (fn) {
-        if (!this._fn) {
-            return {_fn: fn};
-        }
-        console.log('rawrrr!', this._actions);
-    })
-    .done();
-
-pf.curry('foo').curry('bar')('hello');

package/test.js

@@ -1,14 +0,0 @@
-var test = require('tap').test;
-
-test('curry examples', function (t) {
-    function fn(a, b, c, d) {
-        return [a, b, c, d].join();
-    }
-    function okay_sir(str) {
-        t.equals(str, 'hello,world,foo,bar');
-    }
-    okay_sir(pf(fn).curry('hello', 'world')('foo', 'bar'));
-    okay_sir(pf.curry(fn, 'hello', 'world')('foo', 'bar'));
-    okay_sir(pf.curry('hello')(fn).curry('world')('foo', 'bar'));
-    t.end();
-});