dktcli 1.0.0__py3-none-any.whl

devkittools/tools/httptool.py

@@ -0,0 +1,131 @@
+"""dkt http (req) - a tiny, pretty HTTP client for poking at APIs."""
+from __future__ import annotations
+
+import argparse
+import json
+import ssl
+import time
+import urllib.error
+import urllib.request
+
+from ..utils import DktError, c, human_size, info, kv, sym
+
+META = ("Servers & Network", "http", "req", "quick HTTP requests with pretty JSON, timing, headers")
+
+EPILOG = """\
+examples:
+  dkt http https://api.github.com/zen
+  dkt http GET api.example.com/users -H "Authorization: Bearer abc" -i
+  dkt http POST localhost:3000/login -j '{"user":"me","pw":"x"}'
+  dkt http POST httpbin.org/post -d "a=1&b=2"
+  dkt http https://example.com/file.zip -o file.zip
+"""
+
+METHODS = {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, *a, **k):
+        return None
+
+
+def run(args) -> int:
+    items = list(args.target)
+    method = "GET"
+    if items and items[0].upper() in METHODS:
+        method = items.pop(0).upper()
+    if len(items) != 1:
+        raise DktError("Usage: dkt http [METHOD] URL   (see 'dkt http --help')")
+    url = items[0]
+    if "://" not in url:
+        url = ("http://" if url.startswith(("localhost", "127.", "0.0.0.0", "192.168.")) else "https://") + url
+    headers = {"User-Agent": "dkt/1.0", "Accept": "*/*"}
+    for h in args.header or []:
+        if ":" not in h:
+            raise DktError("Header must look like 'Name: value' (got '%s')" % h)
+        k, v = h.split(":", 1)
+        headers[k.strip()] = v.strip()
+    body = None
+    if args.json_body is not None:
+        try:
+            json.loads(args.json_body)
+        except ValueError as e:
+            raise DktError("--json is not valid JSON: %s" % e)
+        body = args.json_body.encode("utf-8")
+        headers.setdefault("Content-Type", "application/json")
+        if method == "GET":
+            method = "POST"
+    elif args.data is not None:
+        body = args.data.encode("utf-8")
+        headers.setdefault("Content-Type", "application/x-www-form-urlencoded")
+        if method == "GET":
+            method = "POST"
+    req = urllib.request.Request(url, data=body, headers=headers, method=method)
+    ctx = ssl.create_default_context()
+    if args.insecure:
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+    handlers = [urllib.request.HTTPSHandler(context=ctx)]
+    if args.no_redirect:
+        handlers.append(_NoRedirect())
+    opener = urllib.request.build_opener(*handlers)
+    t0 = time.perf_counter()
+    try:
+        resp = opener.open(req, timeout=args.timeout)
+    except urllib.error.HTTPError as e:
+        resp = e
+    except urllib.error.URLError as e:
+        raise DktError("Request failed: %s" % e.reason)
+    except (OSError, ValueError) as e:
+        raise DktError("Request failed: %s" % e)
+    data = resp.read()
+    dt = time.perf_counter() - t0
+    status = resp.status if hasattr(resp, "status") else resp.code
+    col = "bgreen" if status < 300 else "byellow" if status < 400 else "bred"
+    print("%s %s  %s  %s  %s" % (c("%d %s" % (status, resp.reason), "bold " + col), c(method, "bold"),
+                                  c("%.0f ms" % (dt * 1000), "gray"), c(human_size(len(data)), "gray"),
+                                  c(resp.geturl() if hasattr(resp, "geturl") else url, "gray")))
+    if args.include or args.head:
+        print()
+        kv([(k, v) for k, v in resp.headers.items()], key_color="bcyan")
+    if args.head or method == "HEAD":
+        return 0 if status < 400 else 1
+    if args.output:
+        with open(args.output, "wb") as f:
+            f.write(data)
+        info(c("%s saved %s to %s" % (sym("ok"), human_size(len(data)), args.output), "green"))
+        return 0 if status < 400 else 1
+    print()
+    text = data.decode(resp.headers.get_content_charset() or "utf-8", errors="replace")
+    ctype = resp.headers.get("Content-Type", "")
+    if "json" in ctype or text.lstrip().startswith(("{", "[")):
+        try:
+            from .jsontool import colorize
+            print(colorize(json.dumps(json.loads(text), indent=2, ensure_ascii=False)))
+            return 0 if status < 400 else 1
+        except ValueError:
+            pass
+    if len(text) > args.max_chars:
+        print(text[:args.max_chars])
+        print(c("\n... truncated (%d more chars, use -o FILE to save)" % (len(text) - args.max_chars), "gray"))
+    else:
+        print(text)
+    return 0 if status < 400 else 1
+
+
+def register(sub, common) -> None:
+    p = sub.add_parser("http", aliases=["req"], parents=[common], help=META[3],
+                       description="Make an HTTP request and show a readable response.",
+                       epilog=EPILOG, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("target", nargs="+", metavar="[METHOD] URL")
+    p.add_argument("-H", "--header", action="append", metavar="'K: V'")
+    p.add_argument("-j", "--json", dest="json_body", metavar="JSON", help="send a JSON body")
+    p.add_argument("-d", "--data", metavar="TEXT", help="send a form/text body")
+    p.add_argument("-i", "--include", action="store_true", help="show response headers")
+    p.add_argument("-I", "--head", action="store_true", help="headers only")
+    p.add_argument("-o", "--output", metavar="FILE", help="save the response body to a file")
+    p.add_argument("--timeout", type=float, default=20)
+    p.add_argument("--no-redirect", action="store_true")
+    p.add_argument("-k", "--insecure", action="store_true", help="skip TLS verification")
+    p.add_argument("--max-chars", type=int, default=20000)
+    p.set_defaults(func=run)

devkittools/tools/ignore.py

@@ -0,0 +1,213 @@
+"""dkt ignore (gi) and dkt license (lic) - generate .gitignore and LICENSE files."""
+from __future__ import annotations
+
+import argparse
+from datetime import date
+from pathlib import Path
+
+from ..utils import DktError, c, confirm, get_setting, ok, resolve_folder, warn
+
+META = ("Project & Code", "ignore", "gi", ".gitignore generator (python, node, java, unity...) + dkt license")
+
+EPILOG = """\
+examples:
+  dkt gi python node           create/merge a .gitignore for Python + Node
+  dkt gi --list                available templates
+  dkt gi unity vscode --print  print instead of writing
+  dkt license mit              write a LICENSE with your name + year
+  dkt license --list
+"""
+
+IGN = {
+    "python": "__pycache__/\n*.py[cod]\n*.egg-info/\n.eggs/\nbuild/\ndist/\n.venv/\nvenv/\nenv/\n.pytest_cache/\n.mypy_cache/\n.ruff_cache/\n.coverage\nhtmlcov/\n.ipynb_checkpoints/\n.tox/",
+    "node": "node_modules/\nnpm-debug.log*\nyarn-error.log*\n.pnpm-store/\n.next/\n.nuxt/\n.turbo/\n.parcel-cache/\ndist/\nbuild/\ncoverage/\n.eslintcache\n*.tsbuildinfo",
+    "java": "*.class\n*.jar\n*.war\ntarget/\n.gradle/\nbuild/\nout/\nhs_err_pid*",
+    "go": "*.exe\n*.test\n*.out\nvendor/\nbin/\n/dist/",
+    "rust": "target/\n**/*.rs.bk\nCargo.lock.bak",
+    "dotnet": "bin/\nobj/\n*.user\n*.suo\n.vs/\npackages/\n*.nupkg\nTestResults/",
+    "c": "*.o\n*.obj\n*.a\n*.lib\n*.so\n*.dll\n*.dylib\n*.exe\n*.out\nbuild/\nCMakeCache.txt\nCMakeFiles/\ncmake-build-*/",
+    "unity": "[Ll]ibrary/\n[Tt]emp/\n[Oo]bj/\n[Bb]uild/\n[Bb]uilds/\n[Ll]ogs/\n[Uu]ser[Ss]ettings/\n*.csproj\n*.sln\n*.pidb\n.vs/\n/[Mm]emory[Cc]aptures/\nsysinfo.txt\n*.apk\n*.aab",
+    "godot": ".godot/\n.import/\nexport.cfg\nexport_presets.cfg\n*.translation\nbuild/",
+    "minecraft": "logs/\ncrash-reports/\nworld*/\n*.log\n*.jar\n!gradle/wrapper/gradle-wrapper.jar\nrun/\n.gradle/\nbuild/",
+    "php": "vendor/\n.phpunit.result.cache\nstorage/*.key\n.env",
+    "ruby": "*.gem\n.bundle/\nvendor/bundle/\nlog/\ntmp/\ncoverage/",
+    "flutter": ".dart_tool/\n.packages\nbuild/\n.flutter-plugins\n.flutter-plugins-dependencies\n*.iml",
+    "env": ".env\n.env.*\n!.env.example\n*.pem\n*.key\nsecrets.json",
+    "vscode": ".vscode/*\n!.vscode/settings.json\n!.vscode/tasks.json\n!.vscode/launch.json\n!.vscode/extensions.json",
+    "jetbrains": ".idea/\n*.iml\n*.ipr\n*.iws\nout/",
+    "macos": ".DS_Store\n.AppleDouble\n.LSOverride\n._*\n.Spotlight-V100\n.Trashes",
+    "windows": "Thumbs.db\nehthumbs.db\nDesktop.ini\n$RECYCLE.BIN/\n*.lnk",
+    "linux": "*~\n.directory\n.Trash-*\n.nfs*",
+    "logs": "*.log\nlogs/\n*.tmp\n*.bak\n*.swp",
+}
+
+LICENSES = {
+    "mit": ("MIT", """MIT License
+
+Copyright (c) {year} {name}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""),
+    "isc": ("ISC", """ISC License
+
+Copyright (c) {year} {name}
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+"""),
+    "bsd-2": ("BSD 2-Clause", """BSD 2-Clause License
+
+Copyright (c) {year}, {name}
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""),
+    "unlicense": ("The Unlicense (public domain)", """This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+For more information, please refer to <https://unlicense.org>
+"""),
+}
+LICENSE_LINKS = {"apache-2.0": "https://www.apache.org/licenses/LICENSE-2.0.txt",
+                 "gpl-3.0": "https://www.gnu.org/licenses/gpl-3.0.txt",
+                 "mpl-2.0": "https://www.mozilla.org/media/MPL/2.0/index.f75d2927d3c1.txt",
+                 "agpl-3.0": "https://www.gnu.org/licenses/agpl-3.0.txt"}
+
+
+def run_ignore(args) -> int:
+    if args.list or not args.templates:
+        print("  " + c("templates:", "bold") + " " + "  ".join(sorted(IGN)))
+        if not args.templates:
+            print(c("\n  usage: dkt gi python node vscode", "gray"))
+        return 0
+    unknown = [t for t in args.templates if t.lower() not in IGN]
+    if unknown:
+        raise DktError("Unknown template(s): %s. See 'dkt gi --list'." % ", ".join(unknown))
+    block = []
+    for t in args.templates:
+        block.append("# --- %s ---\n%s" % (t.lower(), IGN[t.lower()]))
+    text = "\n\n".join(block) + "\n"
+    if args.print:
+        print(text)
+        return 0
+    path = resolve_folder(args.folder) / ".gitignore"
+    if path.exists():
+        existing = path.read_text(encoding="utf-8", errors="replace")
+        have = set(x.strip() for x in existing.splitlines())
+        add = []
+        for t in args.templates:
+            lines = [ln for ln in IGN[t.lower()].splitlines() if ln.strip() not in have]
+            if lines:
+                add.append("# --- %s ---\n%s" % (t.lower(), "\n".join(lines)))
+        if not add:
+            ok(".gitignore already covers everything")
+            return 0
+        path.write_text(existing.rstrip("\n") + "\n\n" + "\n\n".join(add) + "\n", encoding="utf-8")
+        ok("added missing rules to existing .gitignore")
+    else:
+        path.write_text(text, encoding="utf-8")
+        ok("created %s" % path)
+    return 0
+
+
+def run_license(args) -> int:
+    if args.list or not args.kind:
+        for k, (name, _) in LICENSES.items():
+            print("  %s  %s" % (c(k.ljust(10), "bcyan"), name))
+        for k, url in LICENSE_LINKS.items():
+            print("  %s  %s" % (c(k.ljust(10), "gray"), c("download full text: " + url, "gray")))
+        return 0
+    k = args.kind.lower()
+    if k in LICENSE_LINKS:
+        print("  The %s text is long - grab it from: %s" % (k.upper(), LICENSE_LINKS[k]))
+        return 0
+    if k not in LICENSES:
+        raise DktError("Unknown license '%s'. See 'dkt license --list'." % args.kind)
+    name = args.name or get_setting("author")
+    if not name:
+        from ..utils import ask, run_capture
+        try:
+            _, out, _ = run_capture(["git", "config", "user.name"])
+            name = out.strip()
+        except DktError:
+            name = ""
+        name = name or ask("Copyright holder name", "Your Name")
+    text = LICENSES[k][1].format(year=args.year or date.today().year, name=name or "Your Name")
+    path = resolve_folder(args.folder) / "LICENSE"
+    if path.exists() and not args.force and not confirm("LICENSE already exists. Overwrite?"):
+        print("  kept existing LICENSE")
+        return 0
+    path.write_text(text, encoding="utf-8")
+    ok("wrote %s license to %s" % (LICENSES[k][0], path))
+    return 0
+
+
+def register(sub, common) -> None:
+    p = sub.add_parser("ignore", aliases=["gi"], parents=[common], help=META[3],
+                       description="Generate or extend a .gitignore from templates.",
+                       epilog=EPILOG, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("templates", nargs="*")
+    p.add_argument("-f", "--folder", metavar="PATH")
+    p.add_argument("--list", action="store_true")
+    p.add_argument("--print", action="store_true", help="print instead of writing")
+    p.set_defaults(func=run_ignore)
+
+    lp = sub.add_parser("license", aliases=["lic"], parents=[common], help="write a LICENSE file (MIT, ISC, BSD, Unlicense)",
+                        description="Create a LICENSE file.")
+    lp.add_argument("kind", nargs="?", help="mit | isc | bsd-2 | unlicense")
+    lp.add_argument("--name", help="copyright holder (default: git user.name or `dkt config set author ...`)")
+    lp.add_argument("--year", type=int)
+    lp.add_argument("-f", "--folder", metavar="PATH")
+    lp.add_argument("--force", action="store_true", help="overwrite without asking")
+    lp.add_argument("--list", action="store_true")
+    lp.set_defaults(func=run_license)

devkittools/tools/initproj.py

@@ -0,0 +1,166 @@
+"""dkt init (new) - scaffold a new project with sensible defaults."""
+from __future__ import annotations
+
+import argparse
+import re
+from datetime import date
+from pathlib import Path
+
+from ..utils import DktError, c, git, ok, run_capture, sym, tool_version, get_setting, ask
+from .ignore import IGN, LICENSES
+
+META = ("Project & Code", "init", "new", "scaffold a project: python, node, web, cli, with git + license")
+
+EPILOG = """\
+examples:
+  dkt new python mytool           src-layout package with pyproject, tests, .gitignore
+  dkt new node my-api             package.json + index.js
+  dkt new web landing             index.html + style.css + script.js
+  dkt new python mytool --no-git --license isc
+"""
+
+KINDS = ["python", "node", "web"]
+
+
+def w(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+    print("  %s %s" % (c(sym("ok"), "bgreen"), path))
+
+
+def pkg_name(name: str) -> str:
+    return re.sub(r"[^a-z0-9_]", "_", name.lower()).strip("_") or "app"
+
+
+def scaffold_python(root: Path, name: str, author: str) -> None:
+    pkg = pkg_name(name)
+    w(root / "pyproject.toml", '''[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "%s"
+version = "0.1.0"
+description = ""
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [{ name = "%s" }]
+dependencies = []
+
+[project.scripts]
+%s = "%s.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+''' % (name, author, name, pkg))
+    w(root / "src" / pkg / "__init__.py", '__version__ = "0.1.0"\n')
+    w(root / "src" / pkg / "cli.py", '''import argparse
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="%s")
+    parser.add_argument("name", nargs="?", default="world")
+    args = parser.parse_args(argv)
+    print("Hello, %%s!" %% args.name)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+''' % name)
+    w(root / "src" / pkg / "__main__.py", "from .cli import main\n\nraise SystemExit(main())\n")
+    w(root / "tests" / ("test_%s.py" % pkg), '''import unittest
+
+from %s.cli import main
+
+
+class TestCli(unittest.TestCase):
+    def test_runs(self):
+        self.assertEqual(main(["dev"]), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
+''' % pkg)
+    w(root / "README.md", "# %s\n\n## Install\n```bash\npip install -e .\n```\n\n## Run\n```bash\n%s\n```\n" % (name, name))
+
+
+def scaffold_node(root: Path, name: str, author: str) -> None:
+    w(root / "package.json", '''{
+  "name": "%s",
+  "version": "0.1.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": { "start": "node index.js", "test": "node --test" },
+  "author": "%s",
+  "license": "MIT"
+}
+''' % (name, author))
+    w(root / "index.js", "console.log('Hello from %s');\n" % name)
+    w(root / "README.md", "# %s\n\n```bash\nnpm start\n```\n" % name)
+
+
+def scaffold_web(root: Path, name: str, author: str) -> None:
+    w(root / "index.html", '''<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>%s</title>
+  <link rel="stylesheet" href="style.css">
+</head>
+<body>
+  <main>
+    <h1>%s</h1>
+    <p>Edit <code>index.html</code> and run <code>dkt serve --open</code>.</p>
+  </main>
+  <script src="script.js"></script>
+</body>
+</html>
+''' % (name, name))
+    w(root / "style.css", ''':root { color-scheme: light dark; }
+body { font-family: system-ui, sans-serif; margin: 0; display: grid; min-height: 100vh; place-items: center; }
+main { max-width: 40rem; padding: 2rem; }
+''')
+    w(root / "script.js", "console.log('ready');\n")
+    w(root / "README.md", "# %s\n\n```bash\ndkt serve --open\n```\n" % name)
+
+
+def run(args) -> int:
+    root = Path(args.name).expanduser().resolve()
+    if root.exists() and any(root.iterdir()):
+        raise DktError("%s already exists and is not empty." % root)
+    name = root.name
+    author = args.author or get_setting("author") or ""
+    if not author:
+        try:
+            author = run_capture(["git", "config", "user.name"])[1].strip()
+        except DktError:
+            author = ""
+    author = author or "Your Name"
+    print("\n  creating %s project %s\n" % (c(args.kind, "bold bcyan"), c(name, "bold")))
+    {"python": scaffold_python, "node": scaffold_node, "web": scaffold_web}[args.kind](root, name, author)
+    ign = {"python": ["python"], "node": ["node"], "web": []}[args.kind] + ["env", "vscode", "macos", "windows"]
+    w(root / ".gitignore", "\n\n".join(IGN[i] for i in ign) + "\n")
+    if args.license != "none":
+        w(root / "LICENSE", LICENSES[args.license][1].format(year=date.today().year, name=author))
+    if not args.no_git:
+        code, _, err = run_capture(["git", "init", str(root)])
+        if code == 0:
+            ok("initialized git repository")
+        else:
+            print(c("  (git init skipped: %s)" % err.strip(), "gray"))
+    print("\n  next:  cd %s\n" % root.name)
+    return 0
+
+
+def register(sub, common) -> None:
+    p = sub.add_parser("init", aliases=["new"], parents=[common], help=META[3],
+                       description="Create a new project folder from a template.",
+                       epilog=EPILOG, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("kind", choices=KINDS)
+    p.add_argument("name", help="folder / project name")
+    p.add_argument("--license", choices=list(LICENSES) + ["none"], default="mit")
+    p.add_argument("--author")
+    p.add_argument("--no-git", action="store_true")
+    p.set_defaults(func=run)